From 9018ac978db99a3d39f526013049680bbd6c3678 Mon Sep 17 00:00:00 2001 From: Shauren Date: Sat, 26 Mar 2016 17:23:35 +0100 Subject: Core/Shared: Added generated protobuf sources --- src/server/CMakeLists.txt | 1 + src/server/proto/BattlenetRpcErrorCodes.h | 671 + src/server/proto/CMakeLists.txt | 62 + src/server/proto/Client/account_service.pb.cc | 11466 ++++++++++++++ src/server/proto/Client/account_service.pb.h | 6583 ++++++++ src/server/proto/Client/account_types.pb.cc | 15012 +++++++++++++++++++ src/server/proto/Client/account_types.pb.h | 10138 +++++++++++++ src/server/proto/Client/attribute_types.pb.cc | 1385 ++ src/server/proto/Client/attribute_types.pb.h | 1113 ++ .../proto/Client/authentication_service.pb.cc | 7731 ++++++++++ .../proto/Client/authentication_service.pb.h | 5043 +++++++ src/server/proto/Client/challenge_service.pb.cc | 4746 ++++++ src/server/proto/Client/challenge_service.pb.h | 3113 ++++ src/server/proto/Client/channel_service.pb.cc | 6487 ++++++++ src/server/proto/Client/channel_service.pb.h | 4053 +++++ src/server/proto/Client/channel_types.pb.cc | 3717 +++++ src/server/proto/Client/channel_types.pb.h | 2550 ++++ src/server/proto/Client/connection_service.pb.cc | 3876 +++++ src/server/proto/Client/connection_service.pb.h | 2202 +++ src/server/proto/Client/content_handle_types.pb.cc | 496 + src/server/proto/Client/content_handle_types.pb.h | 386 + src/server/proto/Client/entity_types.pb.cc | 1177 ++ src/server/proto/Client/entity_types.pb.h | 739 + src/server/proto/Client/friends_service.pb.cc | 5081 +++++++ src/server/proto/Client/friends_service.pb.h | 2856 ++++ src/server/proto/Client/friends_types.pb.cc | 1654 ++ src/server/proto/Client/friends_types.pb.h | 1310 ++ .../proto/Client/game_utilities_service.pb.cc | 4528 ++++++ .../proto/Client/game_utilities_service.pb.h | 2654 ++++ src/server/proto/Client/game_utilities_types.pb.cc | 742 + src/server/proto/Client/game_utilities_types.pb.h | 471 + .../Client/global_extensions/field_options.pb.cc | 114 + .../Client/global_extensions/field_options.pb.h | 95 + .../Client/global_extensions/method_options.pb.cc | 96 + .../Client/global_extensions/method_options.pb.h | 70 + .../Client/global_extensions/service_options.pb.cc | 105 + .../Client/global_extensions/service_options.pb.h | 74 + src/server/proto/Client/invitation_types.pb.cc | 3684 +++++ src/server/proto/Client/invitation_types.pb.h | 2801 ++++ src/server/proto/Client/notification_types.pb.cc | 1490 ++ src/server/proto/Client/notification_types.pb.h | 1200 ++ src/server/proto/Client/presence_service.pb.cc | 2651 ++++ src/server/proto/Client/presence_service.pb.h | 1499 ++ src/server/proto/Client/presence_types.pb.cc | 1801 +++ src/server/proto/Client/presence_types.pb.h | 1054 ++ .../proto/Client/profanity_filter_config.pb.cc | 667 + .../proto/Client/profanity_filter_config.pb.h | 439 + src/server/proto/Client/report_service.pb.cc | 912 ++ src/server/proto/Client/report_service.pb.h | 608 + src/server/proto/Client/resource_service.pb.cc | 489 + src/server/proto/Client/resource_service.pb.h | 274 + src/server/proto/Client/role_types.pb.cc | 815 + src/server/proto/Client/role_types.pb.h | 610 + src/server/proto/Client/rpc_config.pb.cc | 1952 +++ src/server/proto/Client/rpc_config.pb.h | 1388 ++ src/server/proto/Client/rpc_types.pb.cc | 2460 +++ src/server/proto/Client/rpc_types.pb.h | 1410 ++ src/server/proto/Client/user_manager_service.pb.cc | 4520 ++++++ src/server/proto/Client/user_manager_service.pb.h | 2411 +++ src/server/proto/Client/user_manager_types.pb.cc | 1009 ++ src/server/proto/Client/user_manager_types.pb.h | 727 + src/server/proto/PrecompiledHeaders/protoPCH.cpp | 1 + src/server/proto/PrecompiledHeaders/protoPCH.h | 13 + src/server/proto/ServiceBase.h | 49 + src/server/shared/CMakeLists.txt | 3 +- 65 files changed, 149533 insertions(+), 1 deletion(-) create mode 100644 src/server/proto/BattlenetRpcErrorCodes.h create mode 100644 src/server/proto/CMakeLists.txt create mode 100644 src/server/proto/Client/account_service.pb.cc create mode 100644 src/server/proto/Client/account_service.pb.h create mode 100644 src/server/proto/Client/account_types.pb.cc create mode 100644 src/server/proto/Client/account_types.pb.h create mode 100644 src/server/proto/Client/attribute_types.pb.cc create mode 100644 src/server/proto/Client/attribute_types.pb.h create mode 100644 src/server/proto/Client/authentication_service.pb.cc create mode 100644 src/server/proto/Client/authentication_service.pb.h create mode 100644 src/server/proto/Client/challenge_service.pb.cc create mode 100644 src/server/proto/Client/challenge_service.pb.h create mode 100644 src/server/proto/Client/channel_service.pb.cc create mode 100644 src/server/proto/Client/channel_service.pb.h create mode 100644 src/server/proto/Client/channel_types.pb.cc create mode 100644 src/server/proto/Client/channel_types.pb.h create mode 100644 src/server/proto/Client/connection_service.pb.cc create mode 100644 src/server/proto/Client/connection_service.pb.h create mode 100644 src/server/proto/Client/content_handle_types.pb.cc create mode 100644 src/server/proto/Client/content_handle_types.pb.h create mode 100644 src/server/proto/Client/entity_types.pb.cc create mode 100644 src/server/proto/Client/entity_types.pb.h create mode 100644 src/server/proto/Client/friends_service.pb.cc create mode 100644 src/server/proto/Client/friends_service.pb.h create mode 100644 src/server/proto/Client/friends_types.pb.cc create mode 100644 src/server/proto/Client/friends_types.pb.h create mode 100644 src/server/proto/Client/game_utilities_service.pb.cc create mode 100644 src/server/proto/Client/game_utilities_service.pb.h create mode 100644 src/server/proto/Client/game_utilities_types.pb.cc create mode 100644 src/server/proto/Client/game_utilities_types.pb.h create mode 100644 src/server/proto/Client/global_extensions/field_options.pb.cc create mode 100644 src/server/proto/Client/global_extensions/field_options.pb.h create mode 100644 src/server/proto/Client/global_extensions/method_options.pb.cc create mode 100644 src/server/proto/Client/global_extensions/method_options.pb.h create mode 100644 src/server/proto/Client/global_extensions/service_options.pb.cc create mode 100644 src/server/proto/Client/global_extensions/service_options.pb.h create mode 100644 src/server/proto/Client/invitation_types.pb.cc create mode 100644 src/server/proto/Client/invitation_types.pb.h create mode 100644 src/server/proto/Client/notification_types.pb.cc create mode 100644 src/server/proto/Client/notification_types.pb.h create mode 100644 src/server/proto/Client/presence_service.pb.cc create mode 100644 src/server/proto/Client/presence_service.pb.h create mode 100644 src/server/proto/Client/presence_types.pb.cc create mode 100644 src/server/proto/Client/presence_types.pb.h create mode 100644 src/server/proto/Client/profanity_filter_config.pb.cc create mode 100644 src/server/proto/Client/profanity_filter_config.pb.h create mode 100644 src/server/proto/Client/report_service.pb.cc create mode 100644 src/server/proto/Client/report_service.pb.h create mode 100644 src/server/proto/Client/resource_service.pb.cc create mode 100644 src/server/proto/Client/resource_service.pb.h create mode 100644 src/server/proto/Client/role_types.pb.cc create mode 100644 src/server/proto/Client/role_types.pb.h create mode 100644 src/server/proto/Client/rpc_config.pb.cc create mode 100644 src/server/proto/Client/rpc_config.pb.h create mode 100644 src/server/proto/Client/rpc_types.pb.cc create mode 100644 src/server/proto/Client/rpc_types.pb.h create mode 100644 src/server/proto/Client/user_manager_service.pb.cc create mode 100644 src/server/proto/Client/user_manager_service.pb.h create mode 100644 src/server/proto/Client/user_manager_types.pb.cc create mode 100644 src/server/proto/Client/user_manager_types.pb.h create mode 100644 src/server/proto/PrecompiledHeaders/protoPCH.cpp create mode 100644 src/server/proto/PrecompiledHeaders/protoPCH.h create mode 100644 src/server/proto/ServiceBase.h (limited to 'src') diff --git a/src/server/CMakeLists.txt b/src/server/CMakeLists.txt index f4a7246d9b0..0a8d9ff2c19 100644 --- a/src/server/CMakeLists.txt +++ b/src/server/CMakeLists.txt @@ -26,6 +26,7 @@ if(WIN32) endif(WIN32) add_subdirectory(database) +add_subdirectory(proto) add_subdirectory(shared) add_subdirectory(bnetserver) add_subdirectory(game) diff --git a/src/server/proto/BattlenetRpcErrorCodes.h b/src/server/proto/BattlenetRpcErrorCodes.h new file mode 100644 index 00000000000..f9092ecfa3c --- /dev/null +++ b/src/server/proto/BattlenetRpcErrorCodes.h @@ -0,0 +1,671 @@ +/* + * Copyright (C) 2008-2016 TrinityCore + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see . + */ + +#ifndef BattlenetRpcErrorCodes_h__ +#define BattlenetRpcErrorCodes_h__ + +#include "Define.h" + +enum BattlenetRpcErrorCode : uint32 +{ + ERROR_OK = 0x00000000, + ERROR_INTERNAL = 0x00000001, + ERROR_TIMED_OUT = 0x00000002, + ERROR_DENIED = 0x00000003, + ERROR_NOT_EXISTS = 0x00000004, + ERROR_NOT_STARTED = 0x00000005, + ERROR_IN_PROGRESS = 0x00000006, + ERROR_INVALID_ARGS = 0x00000007, + ERROR_INVALID_SUBSCRIBER = 0x00000008, + ERROR_WAITING_FOR_DEPENDENCY = 0x00000009, + ERROR_NO_AUTH = 0x0000000A, + ERROR_PARENTAL_CONTROL_RESTRICTION = 0x0000000B, + ERROR_NO_GAME_ACCOUNT = 0x0000000C, + ERROR_NOT_IMPLEMENTED = 0x0000000D, + ERROR_OBJECT_REMOVED = 0x0000000E, + ERROR_INVALID_ENTITY_ID = 0x0000000F, + ERROR_INVALID_ENTITY_ACCOUNT_ID = 0x00000010, + ERROR_INVALID_ENTITY_GAME_ACCOUNT_ID = 0x00000011, + ERROR_INVALID_AGENT_ID = 0x00000013, + ERROR_INVALID_TARGET_ID = 0x00000014, + ERROR_MODULE_NOT_LOADED = 0x00000015, + ERROR_MODULE_NO_ENTRY_POINT = 0x00000016, + ERROR_MODULE_SIGNATURE_INCORRECT = 0x00000017, + ERROR_MODULE_CREATE_FAILED = 0x00000018, + ERROR_NO_PROGRAM = 0x00000019, + ERROR_API_NOT_READY = 0x0000001B, + ERROR_BAD_VERSION = 0x0000001C, + ERROR_ATTRIBUTE_TOO_MANY_ATTRIBUTES_SET = 0x0000001D, + ERROR_ATTRIBUTE_MAX_SIZE_EXCEEDED = 0x0000001E, + ERROR_ATTRIBUTE_QUOTA_EXCEEDED = 0x0000001F, + ERROR_SERVER_POOL_SERVER_DISAPPEARED = 0x00000020, + ERROR_SERVER_IS_PRIVATE = 0x00000021, + ERROR_DISABLED = 0x00000022, + ERROR_MODULE_NOT_FOUND = 0x00000024, + ERROR_SERVER_BUSY = 0x00000025, + ERROR_NO_BATTLETAG = 0x00000026, + ERROR_INCOMPLETE_PROFANITY_FILTERS = 0x00000027, + ERROR_INVALID_REGION = 0x00000028, + ERROR_EXISTS_ALREADY = 0x00000029, + ERROR_INVALID_SERVER_THUMBPRINT = 0x0000002A, + ERROR_PHONE_LOCK = 0x0000002B, + ERROR_SQUELCHED = 0x0000002C, + ERROR_TARGET_OFFLINE = 0x0000002D, + ERROR_BAD_SERVER = 0x0000002E, + ERROR_NO_COOKIE = 0x0000002F, + ERROR_EXPIRED_COOKIE = 0x00000030, + ERROR_TOKEN_NOT_FOUND = 0x00000031, + ERROR_GAME_ACCOUNT_NO_TIME = 0x00000032, + ERROR_GAME_ACCOUNT_NO_PLAN = 0x00000033, + ERROR_GAME_ACCOUNT_BANNED = 0x00000034, + ERROR_GAME_ACCOUNT_SUSPENDED = 0x00000035, + ERROR_GAME_ACCOUNT_ALREADY_SELECTED = 0x00000036, + ERROR_GAME_ACCOUNT_CANCELLED = 0x00000037, + ERROR_GAME_ACCOUNT_CREATION_DISABLED = 0x00000038, + ERROR_GAME_ACCOUNT_LOCKED = 0x00000039, + + ERROR_SESSION_DUPLICATE = 0x0000003C, + ERROR_SESSION_DISCONNECTED = 0x0000003D, + ERROR_SESSION_DATA_CHANGED = 0x0000003E, + ERROR_SESSION_UPDATE_FAILED = 0x0000003F, + ERROR_SESSION_NOT_FOUND = 0x00000040, + + ERROR_ADMIN_KICK = 0x00000046, + ERROR_UNPLANNED_MAINTENANCE = 0x00000047, + ERROR_PLANNED_MAINTENANCE = 0x00000048, + ERROR_SERVICE_FAILURE_ACCOUNT = 0x00000049, + ERROR_SERVICE_FAILURE_SESSION = 0x0000004A, + ERROR_SERVICE_FAILURE_AUTH = 0x0000004B, + ERROR_SERVICE_FAILURE_RISK = 0x0000004C, + ERROR_BAD_PROGRAM = 0x0000004D, + ERROR_BAD_LOCALE = 0x0000004E, + ERROR_BAD_PLATFORM = 0x0000004F, + ERROR_LOCALE_RESTRICTED_LA = 0x00000051, + ERROR_LOCALE_RESTRICTED_RU = 0x00000052, + ERROR_LOCALE_RESTRICTED_KO = 0x00000053, + ERROR_LOCALE_RESTRICTED_TW = 0x00000054, + ERROR_LOCALE_RESTRICTED = 0x00000055, + ERROR_ACCOUNT_NEEDS_MAINTENANCE = 0x00000056, + ERROR_MODULE_API_ERROR = 0x00000057, + ERROR_MODULE_BAD_CACHE_HANDLE = 0x00000058, + ERROR_MODULE_ALREADY_LOADED = 0x00000059, + ERROR_NETWORK_BLACKLISTED = 0x0000005A, + ERROR_EVENT_PROCESSOR_SLOW = 0x0000005B, + ERROR_SERVER_SHUTTING_DOWN = 0x0000005C, + ERROR_NETWORK_NOT_PRIVILEGED = 0x0000005D, + ERROR_TOO_MANY_OUTSTANDING_REQUESTS = 0x0000005E, + ERROR_NO_ACCOUNT_REGISTERED = 0x0000005F, + ERROR_BATTLENET_ACCOUNT_BANNED = 0x00000060, + + ERROR_OK_DEPRECATED = 0x00000064, + ERROR_SERVER_IN_MODE_ZOMBIE = 0x00000065, + + ERROR_LOGON_MODULE_REQUIRED = 0x000001F4, + ERROR_LOGON_MODULE_NOT_CONFIGURED = 0x000001F5, + ERROR_LOGON_MODULE_TIMEOUT = 0x000001F6, + ERROR_LOGON_AGREEMENT_REQUIRED = 0x000001FE, + ERROR_LOGON_AGREEMENT_NOT_CONFIGURED = 0x000001FF, + + ERROR_LOGON_INVALID_SERVER_PROOF = 0x00000208, + ERROR_LOGON_WEB_VERIFY_TIMEOUT = 0x00000209, + ERROR_LOGON_INVALID_AUTH_TOKEN = 0x0000020A, + + ERROR_CHALLENGE_SMS_TOO_SOON = 0x00000258, + ERROR_CHALLENGE_SMS_THROTTLED = 0x00000259, + ERROR_CHALLENGE_SMS_TEMP_OUTAGE = 0x0000025A, + ERROR_CHALLENGE_NO_CHALLENGE = 0x0000025B, + ERROR_CHALLENGE_NOT_PICKED = 0x0000025C, + ERROR_CHALLENGE_ALREADY_PICKED = 0x0000025D, + ERROR_CHALLENGE_IN_PROGRESS = 0x0000025E, + + ERROR_CONFIG_FORMAT_INVALID = 0x000002BC, + ERROR_CONFIG_NOT_FOUND = 0x000002BD, + ERROR_CONFIG_RETRIEVE_FAILED = 0x000002BE, + + ERROR_NETWORK_MODULE_BUSY = 0x000003E8, + ERROR_NETWORK_MODULE_CANT_RESOLVE_ADDRESS = 0x000003E9, + ERROR_NETWORK_MODULE_CONNECTION_REFUSED = 0x000003EA, + ERROR_NETWORK_MODULE_INTERRUPTED = 0x000003EB, + ERROR_NETWORK_MODULE_CONNECTION_ABORTED = 0x000003EC, + ERROR_NETWORK_MODULE_CONNECTION_RESET = 0x000003ED, + ERROR_NETWORK_MODULE_BAD_ADDRESS = 0x000003EE, + ERROR_NETWORK_MODULE_NOT_READY = 0x000003EF, + ERROR_NETWORK_MODULE_ALREADY_CONNECTED = 0x000003F0, + ERROR_NETWORK_MODULE_CANT_CREATE_SOCKET = 0x000003F1, + ERROR_NETWORK_MODULE_NETWORK_UNREACHABLE = 0x000003F2, + ERROR_NETWORK_MODULE_SOCKET_PERMISSION_DENIED = 0x000003F3, + ERROR_NETWORK_MODULE_NOT_INITIALIZED = 0x000003F4, + ERROR_NETWORK_MODULE_NO_SSL_CERTIFICATE_FOR_PEER = 0x000003F5, + ERROR_NETWORK_MODULE_NO_SSL_COMMON_NAME_FOR_CERTIFICATE = 0x000003F6, + ERROR_NETWORK_MODULE_SSL_COMMON_NAME_DOES_NOT_MATCH_REMOTE_ENDPOINT = 0x000003F7, + ERROR_NETWORK_MODULE_SOCKET_CLOSED = 0x000003F8, + ERROR_NETWORK_MODULE_SSL_PEER_IS_NOT_REGISTERED_IN_CERTBUNDLE = 0x000003F9, + ERROR_NETWORK_MODULE_SSL_INITIALIZE_LOW_FIRST = 0x000003FA, + ERROR_NETWORK_MODULE_SSL_CERT_BUNDLE_READ_ERROR = 0x000003FB, + ERROR_NETWORK_MODULE_NO_CERT_BUNDLE = 0x000003FC, + ERROR_NETWORK_MODULE_FAILED_TO_DOWNLOAD_CERT_BUNDLE = 0x000003FD, + ERROR_NETWORK_MODULE_NOT_READY_TO_READ = 0x000003FE, + + ERROR_NETWORK_MODULE_OPENSSL_X509_OK = 0x000004B0, + ERROR_NETWORK_MODULE_OPENSSL_X509_UNABLE_TO_GET_ISSUER_CERT = 0x000004B1, + ERROR_NETWORK_MODULE_OPENSSL_X509_UNABLE_TO_GET_CRL = 0x000004B2, + ERROR_NETWORK_MODULE_OPENSSL_X509_UNABLE_TO_DECRYPT_CERT_SIGNATURE = 0x000004B3, + ERROR_NETWORK_MODULE_OPENSSL_X509_UNABLE_TO_DECRYPT_CRL_SIGNATURE = 0x000004B4, + ERROR_NETWORK_MODULE_OPENSSL_X509_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY = 0x000004B5, + ERROR_NETWORK_MODULE_OPENSSL_X509_CERT_SIGNATURE_FAILURE = 0x000004B6, + ERROR_NETWORK_MODULE_OPENSSL_X509_CRL_SIGNATURE_FAILURE = 0x000004B7, + ERROR_NETWORK_MODULE_OPENSSL_X509_CERT_NOT_YET_VALID = 0x000004B8, + ERROR_NETWORK_MODULE_OPENSSL_X509_CERT_HAS_EXPIRED = 0x000004B9, + ERROR_NETWORK_MODULE_OPENSSL_X509_CRL_NOT_YET_VALID = 0x000004BA, + ERROR_NETWORK_MODULE_OPENSSL_X509_CRL_HAS_EXPIRED = 0x000004BB, + ERROR_NETWORK_MODULE_OPENSSL_X509_ERROR_IN_CERT_NOT_BEFORE_FIELD = 0x000004BC, + ERROR_NETWORK_MODULE_OPENSSL_X509_ERROR_IN_CERT_NOT_AFTER_FIELD = 0x000004BD, + ERROR_NETWORK_MODULE_OPENSSL_X509_ERROR_IN_CRL_LAST_UPDATE_FIELD = 0x000004BE, + ERROR_NETWORK_MODULE_OPENSSL_X509_ERROR_IN_CRL_NEXT_UPDATE_FIELD = 0x000004BF, + ERROR_NETWORK_MODULE_OPENSSL_X509_OUT_OF_MEM = 0x000004C0, + ERROR_NETWORK_MODULE_OPENSSL_X509_DEPTH_ZERO_SELF_SIGNED_CERT = 0x000004C1, + ERROR_NETWORK_MODULE_OPENSSL_X509_SELF_SIGNED_CERT_IN_CHAIN = 0x000004C2, + ERROR_NETWORK_MODULE_OPENSSL_X509_UNABLE_TO_GET_ISSUER_CERT_LOCALLY = 0x000004C3, + ERROR_NETWORK_MODULE_OPENSSL_X509_UNABLE_TO_VERIFY_LEAF_SIGNATURE = 0x000004C4, + ERROR_NETWORK_MODULE_OPENSSL_X509_CERT_CHAIN_TOO_LONG = 0x000004C5, + ERROR_NETWORK_MODULE_OPENSSL_X509_CERT_REVOKED = 0x000004C6, + ERROR_NETWORK_MODULE_OPENSSL_X509_INVALID_CA = 0x000004C7, + ERROR_NETWORK_MODULE_OPENSSL_X509_PATH_LENGTH_EXCEEDED = 0x000004C8, + ERROR_NETWORK_MODULE_OPENSSL_X509_INVALID_PURPOSE = 0x000004C9, + ERROR_NETWORK_MODULE_OPENSSL_X509_CERT_UNTRUSTED = 0x000004CA, + ERROR_NETWORK_MODULE_OPENSSL_X509_CERT_REJECTED = 0x000004CB, + ERROR_NETWORK_MODULE_OPENSSL_X509_SUBJECT_ISSUER_MISMATCH = 0x000004CC, + ERROR_NETWORK_MODULE_OPENSSL_X509_AKID_SKID_MISMATCH = 0x000004CD, + ERROR_NETWORK_MODULE_OPENSSL_X509_AKID_ISSUER_SERIAL_MISMATCH = 0x000004CE, + ERROR_NETWORK_MODULE_OPENSSL_X509_KEYUSAGE_NO_CERTSIGN = 0x000004CF, + ERROR_NETWORK_MODULE_OPENSSL_X509_APPLICATION_VERIFICATION = 0x000004D0, + + ERROR_NETWORK_MODULE_SCHANNEL_CANNOT_FIND_OS_VERSION = 0x00000514, + ERROR_NETWORK_MODULE_SCHANNEL_OS_NOT_SUPPORTED = 0x00000515, + ERROR_NETWORK_MODULE_SCHANNEL_LOADLIBRARY_FAIL = 0x00000516, + ERROR_NETWORK_MODULE_SCHANNEL_CANNOT_FIND_INTERFACE = 0x00000517, + ERROR_NETWORK_MODULE_SCHANNEL_INIT_FAIL = 0x00000518, + ERROR_NETWORK_MODULE_SCHANNEL_FUNCTION_CALL_FAIL = 0x00000519, + ERROR_NETWORK_MODULE_SCHANNEL_X509_UNABLE_TO_GET_ISSUER_CERT = 0x00000546, + ERROR_NETWORK_MODULE_SCHANNEL_X509_TIME_INVALID = 0x00000547, + ERROR_NETWORK_MODULE_SCHANNEL_X509_SIGNATURE_INVALID = 0x00000548, + ERROR_NETWORK_MODULE_SCHANNEL_X509_UNABLE_TO_VERIFY_LEAF_SIGNATURE = 0x00000549, + ERROR_NETWORK_MODULE_SCHANNEL_X509_SELF_SIGNED_LEAF_CERTIFICATE = 0x0000054A, + ERROR_NETWORK_MODULE_SCHANNEL_X509_UNHANDLED_ERROR = 0x0000054B, + ERROR_NETWORK_MODULE_SCHANNEL_X509_SELF_SIGNED_CERT_IN_CHAIN = 0x0000054C, + + ERROR_WEBSOCKET_HANDSHAKE = 0x00000578, + + ERROR_NETWORK_MODULE_DURANGO_UNKNOWN = 0x000005DC, + ERROR_NETWORK_MODULE_DURANGO_MALFORMED_HOST_NAME = 0x000005DD, + ERROR_NETWORK_MODULE_DURANGO_INVALID_CONNECTION_RESPONSE = 0x000005DE, + ERROR_NETWORK_MODULE_DURANGO_INVALID_CA_CERT = 0x000005DF, + + ERROR_RPC_WRITE_FAILED = 0x00000BB8, + ERROR_RPC_SERVICE_NOT_BOUND = 0x00000BB9, + ERROR_RPC_TOO_MANY_REQUESTS = 0x00000BBA, + ERROR_RPC_PEER_UNKNOWN = 0x00000BBB, + ERROR_RPC_PEER_UNAVAILABLE = 0x00000BBC, + ERROR_RPC_PEER_DISCONNECTED = 0x00000BBD, + ERROR_RPC_REQUEST_TIMED_OUT = 0x00000BBE, + ERROR_RPC_CONNECTION_TIMED_OUT = 0x00000BBF, + ERROR_RPC_MALFORMED_RESPONSE = 0x00000BC0, + ERROR_RPC_ACCESS_DENIED = 0x00000BC1, + ERROR_RPC_INVALID_SERVICE = 0x00000BC2, + ERROR_RPC_INVALID_METHOD = 0x00000BC3, + ERROR_RPC_INVALID_OBJECT = 0x00000BC4, + ERROR_RPC_MALFORMED_REQUEST = 0x00000BC5, + ERROR_RPC_QUOTA_EXCEEDED = 0x00000BC6, + ERROR_RPC_NOT_IMPLEMENTED = 0x00000BC7, + ERROR_RPC_SERVER_ERROR = 0x00000BC8, + ERROR_RPC_SHUTDOWN = 0x00000BC9, + ERROR_RPC_DISCONNECT = 0x00000BCA, + ERROR_RPC_DISCONNECT_IDLE = 0x00000BCB, + ERROR_RPC_PROTOCOL_ERROR = 0x00000BCC, + ERROR_RPC_NOT_READY = 0x00000BCD, + ERROR_RPC_FORWARD_FAILED = 0x00000BCE, + ERROR_RPC_ENCRYPTION_FAILED = 0x00000BCF, + ERROR_RPC_INVALID_ADDRESS = 0x00000BD0, + ERROR_RPC_METHOD_DISABLED = 0x00000BD1, + ERROR_RPC_SHARD_NOT_FOUND = 0x00000BD2, + ERROR_RPC_INVALID_CONNECTION_ID = 0x00000BD3, + ERROR_RPC_NOT_CONNECTED = 0x00000BD4, + ERROR_RPC_INVALID_CONNECTION_STATE = 0x00000BD5, + ERROR_RPC_SERVICE_ALREADY_REGISTERED = 0x00000BD6, + + ERROR_PRESENCE_INVALID_FIELD_ID = 0x00000FA0, + ERROR_PRESENCE_NO_VALID_SUBSCRIBERS = 0x00000FA1, + ERROR_PRESENCE_ALREADY_SUBSCRIBED = 0x00000FA2, + ERROR_PRESENCE_CONSUMER_NOT_FOUND = 0x00000FA3, + ERROR_PRESENCE_CONSUMER_IS_NULL = 0x00000FA4, + ERROR_PRESENCE_TEMPORARY_OUTAGE = 0x00000FA5, + ERROR_PRESENCE_TOO_MANY_SUBSCRIPTIONS = 0x00000FA6, + ERROR_PRESENCE_SUBSCRIPTION_CANCELLED = 0x00000FA7, + ERROR_PRESENCE_RICH_PRESENCE_PARSE_ERROR = 0x00000FA8, + ERROR_PRESENCE_RICH_PRESENCE_XML_ERROR = 0x00000FA9, + ERROR_PRESENCE_RICH_PRESENCE_LOAD_ERROR = 0x00000FAA, + + ERROR_FRIENDS_TOO_MANY_SENT_INVITATIONS = 0x00001389, + ERROR_FRIENDS_TOO_MANY_RECEIVED_INVITATIONS = 0x0000138A, + ERROR_FRIENDS_FRIENDSHIP_ALREADY_EXISTS = 0x0000138B, + ERROR_FRIENDS_FRIENDSHIP_DOES_NOT_EXIST = 0x0000138C, + ERROR_FRIENDS_INVITATION_ALREADY_EXISTS = 0x0000138D, + ERROR_FRIENDS_INVALID_INVITATION = 0x0000138E, + ERROR_FRIENDS_ALREADY_SUBSCRIBED = 0x0000138F, + ERROR_FRIENDS_ACCOUNT_BLOCKED = 0x00001391, + ERROR_FRIENDS_NOT_SUBSCRIBED = 0x00001392, + ERROR_FRIENDS_INVALID_ROLE_ID = 0x00001393, + ERROR_FRIENDS_DISABLED_ROLE_ID = 0x00001394, + ERROR_FRIENDS_NOTE_MAX_SIZE_EXCEEDED = 0x00001395, + ERROR_FRIENDS_UPDATE_FRIEND_STATE_FAILED = 0x00001396, + ERROR_FRIENDS_INVITEE_AT_MAX_FRIENDS = 0x00001397, + ERROR_FRIENDS_INVITER_AT_MAX_FRIENDS = 0x00001398, + + ERROR_PLATFORM_STORAGE_FILE_WRITE_DENIED = 0x00001770, + + ERROR_WHISPER_UNDELIVERABLE = 0x00001B58, + ERROR_WHISPER_MAX_SIZE_EXCEEDED = 0x00001B59, + + ERROR_USER_MANAGER_ALREADY_BLOCKED = 0x00001F40, + ERROR_USER_MANAGER_NOT_BLOCKED = 0x00001F41, + ERROR_USER_MANAGER_CANNOT_BLOCK_SELF = 0x00001F42, + ERROR_USER_MANAGER_ALREADY_REGISTERED = 0x00001F43, + ERROR_USER_MANAGER_NOT_REGISTERED = 0x00001F44, + ERROR_USER_MANAGER_TOO_MANY_BLOCKED_ENTITIES = 0x00001F45, + ERROR_USER_MANAGER_TOO_MANY_IDS = 0x00001F47, + ERROR_USER_MANAGER_BLOCK_RECORD_UNAVAILABLE = 0x00001F4F, + ERROR_USER_MANAGER_BLOCK_ENTITY_FAILED = 0x00001F50, + ERROR_USER_MANAGER_UNBLOCK_ENTITY_FAILED = 0x00001F51, + ERROR_USER_MANAGER_CANNOT_BLOCK_FRIEND = 0x00001F53, + + ERROR_SOCIAL_NETWORK_DB_EXCEPTION = 0x00002328, + ERROR_SOCIAL_NETWORK_DENIAL_FROM_PROVIDER = 0x00002329, + ERROR_SOCIAL_NETWORK_INVALID_SNS_ID = 0x0000232A, + ERROR_SOCIAL_NETWORK_CANT_SEND_TO_PROVIDER = 0x0000232B, + ERROR_SOCIAL_NETWORK_EX_COMM_FAILED = 0x0000232C, + ERROR_SOCIAL_NETWORK_DISABLED = 0x0000232D, + ERROR_SOCIAL_NETWORK_MISSING_REQUEST_PARAM = 0x0000232E, + ERROR_SOCIAL_NETWORK_UNSUPPORTED_OAUTH_VERSION = 0x0000232F, + + ERROR_CHANNEL_FULL = 0x00002710, + ERROR_CHANNEL_NO_CHANNEL = 0x00002711, + ERROR_CHANNEL_NOT_MEMBER = 0x00002712, + ERROR_CHANNEL_ALREADY_MEMBER = 0x00002713, + ERROR_CHANNEL_NO_SUCH_MEMBER = 0x00002714, + ERROR_CHANNEL_INVALID_CHANNEL_ID = 0x00002716, + ERROR_CHANNEL_NO_SUCH_INVITATION = 0x00002718, + ERROR_CHANNEL_TOO_MANY_INVITATIONS = 0x00002719, + ERROR_CHANNEL_INVITATION_ALREADY_EXISTS = 0x0000271A, + ERROR_CHANNEL_INVALID_CHANNEL_SIZE = 0x0000271B, + ERROR_CHANNEL_INVALID_ROLE_ID = 0x0000271C, + ERROR_CHANNEL_ROLE_NOT_ASSIGNABLE = 0x0000271D, + ERROR_CHANNEL_INSUFFICIENT_PRIVILEGES = 0x0000271E, + ERROR_CHANNEL_INSUFFICIENT_PRIVACY_LEVEL = 0x0000271F, + ERROR_CHANNEL_INVALID_PRIVACY_LEVEL = 0x00002720, + ERROR_CHANNEL_TOO_MANY_CHANNELS_JOINED = 0x00002721, + ERROR_CHANNEL_INVITATION_ALREADY_SUBSCRIBED = 0x00002722, + ERROR_CHANNEL_INVALID_CHANNEL_DELEGATE = 0x00002723, + ERROR_CHANNEL_SLOT_ALREADY_RESERVED = 0x00002724, + ERROR_CHANNEL_SLOT_NOT_RESERVED = 0x00002725, + ERROR_CHANNEL_NO_RESERVED_SLOTS_AVAILABLE = 0x00002726, + ERROR_CHANNEL_INVALID_ROLE_SET = 0x00002727, + ERROR_CHANNEL_REQUIRE_FRIEND_VALIDATION = 0x00002728, + ERROR_CHANNEL_MEMBER_OFFLINE = 0x00002729, + ERROR_CHANNEL_RECEIVED_TOO_MANY_INVITATIONS = 0x0000272A, + ERROR_CHANNEL_INVITATION_INVALID_GAME_ACCOUNT_SELECTED = 0x0000272B, + ERROR_CHANNEL_UNREACHABLE = 0x0000272C, + ERROR_CHANNEL_INVITATION_NOT_SUBSCRIBED = 0x0000272D, + ERROR_CHANNEL_INVALID_MESSAGE_SIZE = 0x0000272E, + ERROR_CHANNEL_MAX_MESSAGE_SIZE_EXCEEDED = 0x0000272F, + ERROR_CHANNEL_CONFIG_NOT_FOUND = 0x00002730, + ERROR_CHANNEL_INVALID_CHANNEL_TYPE = 0x00002731, + + ERROR_LOCAL_STORAGE_FILE_OPEN_ERROR = 0x00002AF8, + ERROR_LOCAL_STORAGE_FILE_CREATE_ERROR = 0x00002AF9, + ERROR_LOCAL_STORAGE_FILE_READ_ERROR = 0x00002AFA, + ERROR_LOCAL_STORAGE_FILE_WRITE_ERROR = 0x00002AFB, + ERROR_LOCAL_STORAGE_FILE_DELETE_ERROR = 0x00002AFC, + ERROR_LOCAL_STORAGE_FILE_COPY_ERROR = 0x00002AFD, + ERROR_LOCAL_STORAGE_FILE_DECOMPRESS_ERROR = 0x00002AFE, + ERROR_LOCAL_STORAGE_FILE_HASH_MISMATCH = 0x00002AFF, + ERROR_LOCAL_STORAGE_FILE_USAGE_MISMATCH = 0x00002B00, + ERROR_LOCAL_STORAGE_DATABASE_INIT_ERROR = 0x00002B01, + ERROR_LOCAL_STORAGE_DATABASE_NEEDS_REBUILD = 0x00002B02, + ERROR_LOCAL_STORAGE_DATABASE_INSERT_ERROR = 0x00002B03, + ERROR_LOCAL_STORAGE_DATABASE_LOOKUP_ERROR = 0x00002B04, + ERROR_LOCAL_STORAGE_DATABASE_UPDATE_ERROR = 0x00002B05, + ERROR_LOCAL_STORAGE_DATABASE_DELETE_ERROR = 0x00002B06, + ERROR_LOCAL_STORAGE_DATABASE_SHRINK_ERROR = 0x00002B07, + ERROR_LOCAL_STORAGE_CACHE_CRAWL_ERROR = 0x00002B08, + ERROR_LOCAL_STORAGE_DATABASE_INDEX_TRIGGER_ERROR = 0x00002B09, + ERROR_LOCAL_STORAGE_DATABASE_REBUILD_IN_PROGRESS = 0x00002B0A, + ERROR_LOCAL_STORAGE_OK_BUT_NOT_IN_CACHE = 0x00002B0B, + ERROR_LOCAL_STORAGE_DATABASE_REBUILD_INTERRUPTED = 0x00002B0D, + ERROR_LOCAL_STORAGE_DATABASE_NOT_INITIALIZED = 0x00002B0E, + ERROR_LOCAL_STORAGE_DIRECTORY_CREATE_ERROR = 0x00002B0F, + ERROR_LOCAL_STORAGE_FILEKEY_NOT_FOUND = 0x00002B10, + ERROR_LOCAL_STORAGE_NOT_AVAILABLE_ON_SERVER = 0x00002B11, + + ERROR_REGISTRY_CREATE_KEY_ERROR = 0x00002EE0, + ERROR_REGISTRY_OPEN_KEY_ERROR = 0x00002EE1, + ERROR_REGISTRY_READ_ERROR = 0x00002EE2, + ERROR_REGISTRY_WRITE_ERROR = 0x00002EE3, + ERROR_REGISTRY_TYPE_ERROR = 0x00002EE4, + ERROR_REGISTRY_DELETE_ERROR = 0x00002EE5, + ERROR_REGISTRY_ENCRYPT_ERROR = 0x00002EE6, + ERROR_REGISTRY_DECRYPT_ERROR = 0x00002EE7, + ERROR_REGISTRY_KEY_SIZE_ERROR = 0x00002EE8, + ERROR_REGISTRY_VALUE_SIZE_ERROR = 0x00002EE9, + ERROR_REGISTRY_NOT_FOUND = 0x00002EEB, + ERROR_REGISTRY_MALFORMED_STRING = 0x00002EEC, + + ERROR_INTERFACE_ALREADY_CONNECTED = 0x000032C8, + ERROR_INTERFACE_NOT_READY = 0x000032C9, + ERROR_INTERFACE_OPTION_KEY_TOO_LARGE = 0x000032CA, + ERROR_INTERFACE_OPTION_VALUE_TOO_LARGE = 0x000032CB, + ERROR_INTERFACE_OPTION_KEY_INVALID_UTF8_STRING = 0x000032CC, + ERROR_INTERFACE_OPTION_VALUE_INVALID_UTF8_STRING = 0x000032CD, + + ERROR_HTTP_COULDNT_RESOLVE = 0x000036B0, + ERROR_HTTP_COULDNT_CONNECT = 0x000036B1, + ERROR_HTTP_TIMEOUT = 0x000036B2, + ERROR_HTTP_FAILED = 0x000036B3, + ERROR_HTTP_MALFORMED_URL = 0x000036B4, + ERROR_HTTP_DOWNLOAD_ABORTED = 0x000036B5, + ERROR_HTTP_COULDNT_WRITE_FILE = 0x000036B6, + ERROR_HTTP_TOO_MANY_REDIRECTS = 0x000036B7, + ERROR_HTTP_COULDNT_OPEN_FILE = 0x000036B8, + ERROR_HTTP_COULDNT_CREATE_FILE = 0x000036B9, + ERROR_HTTP_COULDNT_READ_FILE = 0x000036BA, + ERROR_HTTP_COULDNT_RENAME_FILE = 0x000036BB, + ERROR_HTTP_COULDNT_CREATE_DIRECTORY = 0x000036BC, + ERROR_HTTP_CURL_IS_NOT_READY = 0x000036BD, + ERROR_HTTP_CANCELLED = 0x000036BE, + + ERROR_HTTP_FILE_NOT_FOUND = 0x00003844, + + ERROR_ACCOUNT_MISSING_CONFIG = 0x00004650, + ERROR_ACCOUNT_DATA_NOT_FOUND = 0x00004651, + ERROR_ACCOUNT_ALREADY_SUBSCRIBED = 0x00004652, + ERROR_ACCOUNT_NOT_SUBSCRIBED = 0x00004653, + ERROR_ACCOUNT_FAILED_TO_PARSE_TIMEZONE_DATA = 0x00004654, + ERROR_ACCOUNT_LOAD_FAILED = 0x00004655, + ERROR_ACCOUNT_LOAD_CANCELLED = 0x00004656, + ERROR_ACCOUNT_DATABASE_INVALIDATE_FAILED = 0x00004657, + ERROR_ACCOUNT_CACHE_INVALIDATE_FAILED = 0x00004658, + ERROR_ACCOUNT_SUBSCRIPTION_PENDING = 0x00004659, + ERROR_ACCOUNT_UNKNOWN_REGION = 0x0000465A, + ERROR_ACCOUNT_DATA_FAILED_TO_PARSE = 0x0000465B, + ERROR_ACCOUNT_UNDERAGE = 0x0000465C, + ERROR_ACCOUNT_IDENTITY_CHECK_PENDING = 0x0000465D, + ERROR_ACCOUNT_IDENTITY_UNVERIFIED = 0x0000465E, + + ERROR_DATABASE_BINDING_COUNT_MISMATCH = 0x00004A38, + ERROR_DATABASE_BINDING_PARSE_FAIL = 0x00004A39, + ERROR_DATABASE_RESULTSET_COLUMNS_MISMATCH = 0x00004A3A, + ERROR_DATABASE_DEADLOCK = 0x00004A3B, + ERROR_DATABASE_DUPLICATE_KEY = 0x00004A3C, + ERROR_DATABASE_CANNOT_CONNECT = 0x00004A3D, + ERROR_DATABASE_STATEMENT_FAILED = 0x00004A3E, + ERROR_DATABASE_TRANSACTION_NOT_STARTED = 0x00004A3F, + ERROR_DATABASE_TRANSACTION_NOT_ENDED = 0x00004A40, + ERROR_DATABASE_TRANSACTION_LEAK = 0x00004A41, + ERROR_DATABASE_TRANSACTION_STATE_BAD = 0x00004A42, + ERROR_DATABASE_SERVER_GONE = 0x00004A43, + ERROR_DATABASE_QUERY_TIMEOUT = 0x00004A44, + ERROR_DATABASE_BINDING_NOT_NULLABLE = 0x00004A9C, + ERROR_DATABASE_BINDING_INVALID_INTEGER = 0x00004A9D, + ERROR_DATABASE_BINDING_INVALID_FLOAT = 0x00004A9E, + ERROR_DATABASE_BINDING_INVALID_TEMPORAL = 0x00004A9F, + ERROR_DATABASE_BINDING_INVALID_PROTOBUF = 0x00004AA0, + + ERROR_PARTY_INVALID_PARTY_ID = 0x00004E20, + ERROR_PARTY_ALREADY_IN_PARTY = 0x00004E21, + ERROR_PARTY_NOT_IN_PARTY = 0x00004E22, + ERROR_PARTY_INVITATION_UNDELIVERABLE = 0x00004E23, + ERROR_PARTY_INVITATION_ALREADY_EXISTS = 0x00004E24, + ERROR_PARTY_TOO_MANY_PARTY_INVITATIONS = 0x00004E25, + ERROR_PARTY_TOO_MANY_RECEIVED_INVITATIONS = 0x00004E26, + ERROR_PARTY_NO_SUCH_TYPE = 0x00004E27, + + ERROR_GAMES_NO_SUCH_FACTORY = 0x000055F0, + ERROR_GAMES_NO_SUCH_GAME = 0x000055F1, + ERROR_GAMES_NO_SUCH_REQUEST = 0x000055F2, + ERROR_GAMES_NO_SUCH_PARTY_MEMBER = 0x000055F3, + + ERROR_RESOURCES_OFFLINE = 0x000059D8, + + ERROR_GAME_SERVER_CREATE_GAME_REFUSED = 0x00005DC0, + ERROR_GAME_SERVER_ADD_PLAYERS_REFUSED = 0x00005DC1, + ERROR_GAME_SERVER_REMOVE_PLAYERS_REFUSED = 0x00005DC2, + ERROR_GAME_SERVER_FINISH_GAME_REFUSED = 0x00005DC3, + ERROR_GAME_SERVER_NO_SUCH_GAME = 0x00005DC4, + ERROR_GAME_SERVER_NO_SUCH_PLAYER = 0x00005DC5, + ERROR_GAME_SERVER_CREATE_GAME_REFUSED_TRANSIENT = 0x00005DF2, + ERROR_GAME_SERVER_ADD_PLAYERS_REFUSED_TRANSIENT = 0x00005DF3, + ERROR_GAME_SERVER_REMOVE_PLAYERS_REFUSED_TRANSIENT = 0x00005DF4, + ERROR_GAME_SERVER_FINISH_GAME_REFUSED_TRANSIENT = 0x00005DF5, + ERROR_GAME_SERVER_CREATE_GAME_REFUSED_BUSY = 0x00005E24, + ERROR_GAME_SERVER_ADD_PLAYERS_REFUSED_BUSY = 0x00005E25, + ERROR_GAME_SERVER_REMOVE_PLAYERS_REFUSED_BUSY = 0x00005E26, + ERROR_GAME_SERVER_FINISH_GAME_REFUSED_BUSY = 0x00005E27, + + ERROR_GAME_MASTER_INVALID_FACTORY = 0x000061A8, + ERROR_GAME_MASTER_INVALID_GAME = 0x000061A9, + ERROR_GAME_MASTER_GAME_FULL = 0x000061AA, + ERROR_GAME_MASTER_REGISTER_FAILED = 0x000061AB, + ERROR_GAME_MASTER_NO_GAME_SERVER = 0x000061AC, + ERROR_GAME_MASTER_NO_UTILITY_SERVER = 0x000061AD, + ERROR_GAME_MASTER_NO_GAME_VERSION = 0x000061AE, + ERROR_GAME_MASTER_GAME_JOIN_FAILED = 0x000061AF, + ERROR_GAME_MASTER_ALREADY_REGISTERED = 0x000061B0, + ERROR_GAME_MASTER_NO_FACTORY = 0x000061B1, + ERROR_GAME_MASTER_MULTIPLE_GAME_VERSIONS = 0x000061B2, + ERROR_GAME_MASTER_INVALID_PLAYER = 0x000061B3, + ERROR_GAME_MASTER_INVALID_GAME_REQUEST = 0x000061B4, + ERROR_GAME_MASTER_INSUFFICIENT_PRIVILEGES = 0x000061B5, + ERROR_GAME_MASTER_ALREADY_IN_GAME = 0x000061B6, + ERROR_GAME_MASTER_INVALID_GAME_SERVER_RESPONSE = 0x000061B7, + ERROR_GAME_MASTER_GAME_ACCOUNT_LOOKUP_FAILED = 0x000061B8, + ERROR_GAME_MASTER_GAME_ENTRY_CANCELLED = 0x000061B9, + ERROR_GAME_MASTER_GAME_ENTRY_ABORTED_CLIENT_DROPPED = 0x000061BA, + ERROR_GAME_MASTER_GAME_ENTRY_ABORTED_BY_SERVICE = 0x000061BB, + ERROR_GAME_MASTER_NO_AVAILABLE_CAPACITY = 0x000061BC, + ERROR_GAME_MASTER_INVALID_TEAM_ID = 0x000061BD, + ERROR_GAME_MASTER_CREATION_IN_PROGRESS = 0x000061BE, + + ERROR_NOTIFICATION_INVALID_CLIENT_ID = 0x00006590, + ERROR_NOTIFICATION_DUPLICATE_NAME = 0x00006591, + ERROR_NOTIFICATION_NAME_NOT_FOUND = 0x00006592, + ERROR_NOTIFICATION_INVALID_SERVER = 0x00006593, + ERROR_NOTIFICATION_QUOTA_EXCEEDED = 0x00006594, + ERROR_NOTIFICATION_INVALID_NOTIFICATION_TYPE = 0x00006595, + ERROR_NOTIFICATION_UNDELIVERABLE = 0x00006596, + ERROR_NOTIFICATION_UNDELIVERABLE_TEMPORARY = 0x00006597, + + ERROR_ACHIEVEMENTS_NOTHING_TO_UPDATE = 0x00006D60, + ERROR_ACHIEVEMENTS_INVALID_PARAMS = 0x00006D61, + ERROR_ACHIEVEMENTS_NOT_REGISTERED = 0x00006D62, + ERROR_ACHIEVEMENTS_NOT_READY = 0x00006D63, + ERROR_ACHIEVEMENTS_FAILED_TO_PARSE_STATIC_DATA = 0x00006D64, + ERROR_ACHIEVEMENTS_UNKNOWN_ID = 0x00006D65, + ERROR_ACHIEVEMENTS_MISSING_SNAPSHOT = 0x00006D66, + ERROR_ACHIEVEMENTS_ALREADY_REGISTERED = 0x00006D67, + ERROR_ACHIEVEMENTS_TOO_MANY_REGISTRATIONS = 0x00006D68, + ERROR_ACHIEVEMENTS_ALREADY_IN_PROGRESS = 0x00006D69, + ERROR_ACHIEVEMENTS_TEMPORARY_OUTAGE = 0x00006D6A, + ERROR_ACHIEVEMENTS_INVALID_PROGRAMID = 0x00006D6B, + ERROR_ACHIEVEMENTS_MISSING_RECORD = 0x00006D6C, + ERROR_ACHIEVEMENTS_REGISTRATION_PENDING = 0x00006D6D, + ERROR_ACHIEVEMENTS_ENTITY_ID_NOT_FOUND = 0x00006D6E, + ERROR_ACHIEVEMENTS_ACHIEVEMENT_ID_NOT_FOUND = 0x00006D6F, + ERROR_ACHIEVEMENTS_CRITERIA_ID_NOT_FOUND = 0x00006D70, + ERROR_ACHIEVEMENTS_STATIC_DATA_MISMATCH = 0x00006D71, + ERROR_ACHIEVEMENTS_WRONG_THREAD = 0x00006D72, + ERROR_ACHIEVEMENTS_CALLBACK_IS_NULL = 0x00006D73, + ERROR_ACHIEVEMENTS_AUTO_REGISTER_PENDING = 0x00006D74, + ERROR_ACHIEVEMENTS_NOT_INITIALIZED = 0x00006D75, + ERROR_ACHIEVEMENTS_ACHIEVEMENT_ID_ALREADY_EXISTS = 0x00006D76, + ERROR_ACHIEVEMENTS_FAILED_TO_DOWNLOAD_STATIC_DATA = 0x00006D77, + ERROR_ACHIEVEMENTS_STATIC_DATA_NOT_FOUND = 0x00006D78, + + ERROR_GAME_UTILITY_SERVER_VARIABLE_REQUEST_REFUSED = 0x000084D1, + ERROR_GAME_UTILITY_SERVER_WRONG_NUMBER_OF_VARIABLES_RETURNED = 0x000084D2, + ERROR_GAME_UTILITY_SERVER_CLIENT_REQUEST_REFUSED = 0x000084D3, + ERROR_GAME_UTILITY_SERVER_PRESENCE_CHANNEL_CREATED_REFUSED = 0x000084D4, + ERROR_GAME_UTILITY_SERVER_VARIABLE_REQUEST_REFUSED_TRANSIENT = 0x00008502, + ERROR_GAME_UTILITY_SERVER_CLIENT_REQUEST_REFUSED_TRANSIENT = 0x00008503, + ERROR_GAME_UTILITY_SERVER_PRESENCE_CHANNEL_CREATED_REFUSED_TRANSIENT = 0x00008504, + ERROR_GAME_UTILITY_SERVER_SERVER_REQUEST_REFUSED_TRANSIENT = 0x00008505, + ERROR_GAME_UTILITY_SERVER_VARIABLE_REQUEST_REFUSED_BUSY = 0x00008534, + ERROR_GAME_UTILITY_SERVER_CLIENT_REQUEST_REFUSED_BUSY = 0x00008535, + ERROR_GAME_UTILITY_SERVER_PRESENCE_CHANNEL_CREATED_REFUSED_BUSY = 0x00008536, + ERROR_GAME_UTILITY_SERVER_SERVER_REQUEST_REFUSED_BUSY = 0x00008537, + ERROR_GAME_UTILITY_SERVER_NO_SERVER = 0x00008598, + + ERROR_IDENTITY_INSUFFICIENT_DATA = 0x0000A028, + ERROR_IDENTITY_TOO_MANY_RESULTS = 0x0000A029, + ERROR_IDENTITY_BAD_ID = 0x0000A02A, + ERROR_IDENTITY_NO_ACCOUNT_BLOB = 0x0000A02B, + + ERROR_RISK_CHALLENGE_ACTION = 0x0000A410, + ERROR_RISK_DELAY_ACTION = 0x0000A411, + ERROR_RISK_THROTTLE_ACTION = 0x0000A412, + ERROR_RISK_ACCOUNT_LOCKED = 0x0000A413, + ERROR_RISK_CS_DENIED = 0x0000A414, + ERROR_RISK_DISCONNECT_ACCOUNT = 0x0000A415, + ERROR_RISK_CHECK_SKIPPED = 0x0000A416, + + ERROR_REPORT_UNAVAILABLE = 0x0000AFC8, + ERROR_REPORT_TOO_LARGE = 0x0000AFC9, + ERROR_REPORT_UNKNOWN_TYPE = 0x0000AFCA, + ERROR_REPORT_ATTRIBUTE_INVALID = 0x0000AFCB, + ERROR_REPORT_ATTRIBUTE_QUOTA_EXCEEDED = 0x0000AFCC, + ERROR_REPORT_UNCONFIRMED = 0x0000AFCD, + ERROR_REPORT_NOT_CONNECTED = 0x0000AFCE, + ERROR_REPORT_REJECTED = 0x0000AFCF, + ERROR_REPORT_TOO_MANY_REQUESTS = 0x0000AFD0, + + ERROR_ACCOUNT_ALREADY_REGISTERD = 0x0000BB80, + ERROR_ACCOUNT_NOT_REGISTERED = 0x0000BB81, + ERROR_ACCOUNT_REGISTRATION_PENDING = 0x0000BB82, + + ERROR_MEMCACHED_CLIENT_NO_ERROR = 0x00010000, + ERROR_MEMCACHED_CLIENT_KEY_NOT_FOUND = 0x00010001, + ERROR_MEMCACHED_KEY_EXISTS = 0x00010002, + ERROR_MEMCACHED_VALUE_TO_LARGE = 0x00010003, + ERROR_MEMCACHED_INVALID_ARGS = 0x00010004, + ERROR_MEMCACHED_ITEM_NOT_STORED = 0x00010005, + ERROR_MEMCACHED_NON_NUMERIC_VALUE = 0x00010006, + ERROR_MEMCACHED_WRONG_SERVER = 0x00010007, + ERROR_MEMCACHED_AUTHENTICATION_ERROR = 0x00010008, + ERROR_MEMCACHED_AUTHENTICATION_CONTINUE = 0x00010009, + ERROR_MEMCACHED_UNKNOWN_COMMAND = 0x0001000A, + ERROR_MEMCACHED_OUT_OF_MEMORY = 0x0001000B, + ERROR_MEMCACHED_NOT_SUPPORTED = 0x0001000C, + ERROR_MEMCACHED_INTERNAL_ERROR = 0x0001000D, + ERROR_MEMCACHED_TEMPORARY_FAILURE = 0x0001000E, + + ERROR_MEMCACHED_CLIENT_ALREADY_CONNECTED = 0x000186A0, + ERROR_MEMCACHED_CLIENT_BAD_CONFIG = 0x000186A1, + ERROR_MEMCACHED_CLIENT_NOT_CONNECTED = 0x000186A2, + ERROR_MEMCACHED_CLIENT_TIMEOUT = 0x000186A3, + ERROR_MEMCACHED_CLIENT_ABORTED = 0x000186A4, + + ERROR_UTIL_SERVER_FAILED_TO_SERIALIZE = 0x80000064, + ERROR_UTIL_SERVER_DISCONNECTED_FROM_BATTLENET = 0x80000065, + ERROR_UTIL_SERVER_TIMED_OUT = 0x80000066, + ERROR_UTIL_SERVER_NO_METERING_DATA = 0x80000067, + ERROR_UTIL_SERVER_FAIL_PERMISSION_CHECK = 0x80000068, + ERROR_UTIL_SERVER_UNKNOWN_REALM = 0x80000069, + ERROR_UTIL_SERVER_MISSING_SESSION_KEY = 0x8000006A, + ERROR_UTIL_SERVER_MISSING_VIRTUAL_REALM = 0x8000006B, + ERROR_UTIL_SERVER_INVALID_SESSION_KEY = 0x8000006C, + ERROR_UTIL_SERVER_MISSING_REALM_LIST = 0x8000006D, + ERROR_UTIL_SERVER_INVALID_IDENTITY_ARGS = 0x8000006E, + ERROR_UTIL_SERVER_SESSION_OBJECT_MISSING = 0x8000006F, + ERROR_UTIL_SERVER_INVALID_BNET_SESSION = 0x80000070, + ERROR_UTIL_SERVER_INVALID_VIRTUAL_REALM = 0x80000071, + ERROR_UTIL_SERVER_INVALID_CLIENT_ADDRESS = 0x80000072, + ERROR_UTIL_SERVER_FAILED_TO_SERIALIZE_RESPONSE = 0x80000073, + ERROR_UTIL_SERVER_UNKNOWN_REQUEST = 0x80000074, + ERROR_UTIL_SERVER_UNABLE_TO_GENERATE_JOIN_TICKET = 0x80000075, + ERROR_UTIL_SERVER_UNABLE_TO_GENERATE_REALM_LIST_TICKET = 0x80000076, + ERROR_UTIL_SERVER_ACCOUNT_DENIED = 0x80000077, + ERROR_UTIL_SERVER_INVALID_WOW_ACCOUNT = 0x80000078, + ERROR_UTIL_SERVER_UNABLE_TO_STORE_SESSION = 0x80000079, + ERROR_UTIL_SERVER_SESSION_ALREADY_CREATED = 0x8000007A, + + ERROR_USER_SERVER_FAILED_TO_SERIALIZE = 0x800000C8, + ERROR_USER_SERVER_DISCONNECTED_FROM_UTIL = 0x800000C9, + ERROR_USER_SERVER_SESSION_DUPLICATE = 0x800000CA, + ERROR_USER_SERVER_FAILED_TO_DISABLE_BILLING = 0x800000CB, + ERROR_USER_SERVER_PLAYER_DISCONNECTED = 0x800000CC, + ERROR_USER_SERVER_FAILED_TO_PARSE_ACCOUNT_STATE = 0x800000CD, + ERROR_USER_SERVER_ACCOUNT_LOAD_CANCELLED = 0x800000CE, + ERROR_USER_SERVER_BAD_PLATFORM = 0x800000CF, + ERROR_USER_SERVER_BAD_VIRTUAL_REALM = 0x800000D0, + ERROR_USER_SERVER_LOCALE_RESTRICTED = 0x800000D1, + ERROR_USER_SERVER_MISSING_PROPASS = 0x800000D2, + ERROR_USER_SERVER_BAD_WOW_ACCOUNT = 0x800000D3, + ERROR_USER_SERVER_BAD_BNET_ACCOUNT = 0x800000D4, + ERROR_USER_SERVER_FAILED_TO_PARSE_GAME_ACCOUNT_STATE = 0x800000D5, + ERROR_USER_SERVER_FAILED_TO_PARSE_GAME_TIME_REMAINING = 0x800000D6, + ERROR_USER_SERVER_FAILED_TO_PARSE_GAME_SESSION_INFO = 0x800000D7, + ERROR_USER_SERVER_ACCOUNT_STATE_POORLY_FORMED = 0x800000D8, + ERROR_USER_SERVER_GAME_ACCOUNT_STATE_POORLY_FORMED = 0x800000D9, + ERROR_USER_SERVER_GAME_TIME_REMAINING_POORLY_FORMED = 0x800000DA, + ERROR_USER_SERVER_GAME_SESSION_INFO_POORLY_FORMED = 0x800000DB, + ERROR_USER_SERVER_BAD_SESSION_TRACKER_STATE = 0x800000DC, + ERROR_USER_SERVER_FAILED_TO_PARSE_CAIS_INFO = 0x800000DD, + ERROR_USER_SERVER_GAME_SESSION_DISCONNECTED = 0x800000DE, + ERROR_USER_SERVER_VERSION_MISMATCH = 0x800000DF, + ERROR_USER_SERVER_ACCOUNT_SUSPENDED = 0x800000E0, + ERROR_USER_SERVER_NOT_PERMITTED_ON_REALM = 0x800000E1, + ERROR_USER_SERVER_LOGIN_FAILED_CONNECT = 0x800000E2, + + ERROR_WOW_SERVICES_TIMED_OUT = 0x8000012C, + ERROR_WOW_SERVICES_INVALID_REALM_LIST_TICKET = 0x8000012D, + ERROR_WOW_SERVICES_INVALID_JOIN_TICKET = 0x8000012E, + ERROR_WOW_SERVICES_INVALID_SERVER_ADDRESSES = 0x8000012F, + ERROR_WOW_SERVICES_INVALID_SECRET_BLOB = 0x80000130, + ERROR_WOW_SERVICES_NO_REALM_JOIN_IP_FOUND = 0x80000131, + ERROR_WOW_SERVICES_DENIED_REALM_LIST_TICKET = 0x80000132, + ERROR_WOW_SERVICES_MISSING_GAME_ACCOUNT = 0x80000133, + ERROR_WOW_SERVICES_LOGON_INVALID_AUTH_TOKEN = 0x80000134, + ERROR_WOW_SERVICES_NO_AVAILABLE_REALMS = 0x80000135, + ERROR_WOW_SERVICES_FAILED_TO_PARSE_DISPATCH = 0x80000136, + ERROR_WOW_SERVICES_MISSING_METERING_FILE = 0x80000137, + ERROR_WOW_SERVICES_LOGIN_INVALID_CONTENT_TYPE = 0x80000138, + ERROR_WOW_SERVICES_LOGIN_UNABLE_TO_DECODE = 0x80000139, + ERROR_WOW_SERVICES_LOGIN_POST_ERROR = 0x8000013A, + ERROR_WOW_SERVICES_AUTHENTICATOR_PARSE_FAILED = 0x8000013B, + ERROR_WOW_SERVICES_LEGAL_PARSE_FAILED = 0x8000013C, + ERROR_WOW_SERVICES_LOGIN_AUTHENTICATION_PARSE_FAILED = 0x8000013D, + ERROR_WOW_SERIVCES_USER_MUST_ACCEPT_LEGAL = 0x8000013E, + ERROR_WOW_SERVICES_DISCONNECTED = 0x8000013F, + ERROR_WOW_SERVICES_NO_HANDLER_FOR_DISPATCH = 0x80000140, + ERROR_WOW_SERVICES_PRE_DISPATCH_HANDLER_FAILED = 0x80000141, + ERROR_WOW_SERVICES_CRITICAL_STREAMING_ERROR = 0x80000142, + ERROR_WOW_SERVICES_WORLD_LOAD_ERROR = 0x80000143, + ERROR_WOW_SERVICES_LOGIN_FAILED = 0x80000144, + ERROR_WOW_SERVICES_LOGIN_FAILED_ON_CHALLENGE = 0x80000145, + ERROR_WOW_SERVICES_NO_PREPAID_TIME = 0x80000146, + ERROR_WOW_SERVICES_SUBSCRIPTION_EXPIRED = 0x80000147, + ERROR_WOW_SERVICES_CANT_CONNECT = 0x80000148, +}; +#endif // BattlenetRpcErrorCodes_h__ diff --git a/src/server/proto/CMakeLists.txt b/src/server/proto/CMakeLists.txt new file mode 100644 index 00000000000..fd20378084f --- /dev/null +++ b/src/server/proto/CMakeLists.txt @@ -0,0 +1,62 @@ +# Copyright (C) 2008-2016 TrinityCore +# +# This file is free software; as a special exception the author gives +# unlimited permission to copy and/or distribute it, with or without +# modifications, as long as this notice is preserved. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY, to the extent permitted by law; without even the +# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + +if (MSVC) + add_definitions(/W0) +else() + add_definitions(-w) +endif() + +CollectSourceFiles( + ${CMAKE_CURRENT_SOURCE_DIR} + PRIVATE_SOURCES + # Exclude + ${CMAKE_CURRENT_SOURCE_DIR}/PrecompiledHeaders) + +if (USE_COREPCH) + set(PRIVATE_PCH_HEADER PrecompiledHeaders/protoPCH.h) + set(PRIVATE_PCH_SOURCE PrecompiledHeaders/protoPCH.cpp) +endif() + +GroupSources(${CMAKE_CURRENT_SOURCE_DIR}) + +add_definitions(-DTRINITY_API_EXPORT_SHARED) + +add_library(proto STATIC + ${PRIVATE_SOURCES} + ${PRIVATE_PCH_SOURCE} +) + +CollectIncludeDirectories( + ${CMAKE_CURRENT_SOURCE_DIR} + PUBLIC_INCLUDES + # Exclude + ${CMAKE_CURRENT_SOURCE_DIR}/PrecompiledHeaders) + +target_include_directories(proto + PUBLIC + ${PUBLIC_INCLUDES} + PRIVATE + ${CMAKE_CURRENT_BINARY_DIR}) + +target_link_libraries(proto + PUBLIC + common + protobuf) + +set_target_properties(proto + PROPERTIES + FOLDER + "server") + +# Generate precompiled header +if (USE_COREPCH) + add_cxx_pch(proto ${PRIVATE_PCH_HEADER} ${PRIVATE_PCH_SOURCE}) +endif() diff --git a/src/server/proto/Client/account_service.pb.cc b/src/server/proto/Client/account_service.pb.cc new file mode 100644 index 00000000000..85b6c4a53c2 --- /dev/null +++ b/src/server/proto/Client/account_service.pb.cc @@ -0,0 +1,11466 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: account_service.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "account_service.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +#include "BattlenetRpcErrorCodes.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { +namespace account { +namespace v1 { + +namespace { + +const ::google::protobuf::Descriptor* GetAccountRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GetAccountRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* GetAccountResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GetAccountResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* CreateGameAccountRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + CreateGameAccountRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* CacheExpireRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + CacheExpireRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* CredentialUpdateRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + CredentialUpdateRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* CredentialUpdateResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + CredentialUpdateResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* AccountFlagUpdateRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AccountFlagUpdateRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* GameAccountFlagUpdateRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GameAccountFlagUpdateRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* SubscriptionUpdateRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SubscriptionUpdateRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* SubscriptionUpdateResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SubscriptionUpdateResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* IsIgrAddressRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + IsIgrAddressRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* AccountServiceRegion_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AccountServiceRegion_reflection_ = NULL; +const ::google::protobuf::Descriptor* AccountServiceConfig_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AccountServiceConfig_reflection_ = NULL; +const ::google::protobuf::Descriptor* GetAccountStateRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GetAccountStateRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* GetAccountStateResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GetAccountStateResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* GetGameAccountStateRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GetGameAccountStateRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* GetGameAccountStateResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GetGameAccountStateResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* GetLicensesRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GetLicensesRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* GetLicensesResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GetLicensesResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* GetGameSessionInfoRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GetGameSessionInfoRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* GetGameSessionInfoResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GetGameSessionInfoResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* GetGameTimeRemainingInfoRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GetGameTimeRemainingInfoRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* GetGameTimeRemainingInfoResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GetGameTimeRemainingInfoResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* GetCAISInfoRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GetCAISInfoRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* GetCAISInfoResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GetCAISInfoResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* ForwardCacheExpireRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ForwardCacheExpireRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* GetAuthorizedDataRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GetAuthorizedDataRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* GetAuthorizedDataResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GetAuthorizedDataResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* AccountStateNotification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AccountStateNotification_reflection_ = NULL; +const ::google::protobuf::Descriptor* GameAccountStateNotification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GameAccountStateNotification_reflection_ = NULL; +const ::google::protobuf::Descriptor* GameAccountNotification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GameAccountNotification_reflection_ = NULL; +const ::google::protobuf::Descriptor* GameAccountSessionNotification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GameAccountSessionNotification_reflection_ = NULL; +const ::google::protobuf::ServiceDescriptor* AccountService_descriptor_ = NULL; +const ::google::protobuf::ServiceDescriptor* AccountListener_descriptor_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_account_5fservice_2eproto() { + protobuf_AddDesc_account_5fservice_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "account_service.proto"); + GOOGLE_CHECK(file != NULL); + GetAccountRequest_descriptor_ = file->message_type(0); + static const int GetAccountRequest_offsets_[9] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, ref_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_all_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_blob_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_email_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_battle_tag_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_full_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_links_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_parental_controls_), + }; + GetAccountRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GetAccountRequest_descriptor_, + GetAccountRequest::default_instance_, + GetAccountRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GetAccountRequest)); + GetAccountResponse_descriptor_ = file->message_type(1); + static const int GetAccountResponse_offsets_[7] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, blob_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, email_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, battle_tag_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, full_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, links_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, parental_control_info_), + }; + GetAccountResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GetAccountResponse_descriptor_, + GetAccountResponse::default_instance_, + GetAccountResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GetAccountResponse)); + CreateGameAccountRequest_descriptor_ = file->message_type(2); + static const int CreateGameAccountRequest_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateGameAccountRequest, account_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateGameAccountRequest, region_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateGameAccountRequest, program_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateGameAccountRequest, realm_permissions_), + }; + CreateGameAccountRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + CreateGameAccountRequest_descriptor_, + CreateGameAccountRequest::default_instance_, + CreateGameAccountRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateGameAccountRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateGameAccountRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(CreateGameAccountRequest)); + CacheExpireRequest_descriptor_ = file->message_type(3); + static const int CacheExpireRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CacheExpireRequest, account_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CacheExpireRequest, game_account_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CacheExpireRequest, email_), + }; + CacheExpireRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + CacheExpireRequest_descriptor_, + CacheExpireRequest::default_instance_, + CacheExpireRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CacheExpireRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CacheExpireRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(CacheExpireRequest)); + CredentialUpdateRequest_descriptor_ = file->message_type(4); + static const int CredentialUpdateRequest_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CredentialUpdateRequest, account_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CredentialUpdateRequest, old_credentials_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CredentialUpdateRequest, new_credentials_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CredentialUpdateRequest, region_), + }; + CredentialUpdateRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + CredentialUpdateRequest_descriptor_, + CredentialUpdateRequest::default_instance_, + CredentialUpdateRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CredentialUpdateRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CredentialUpdateRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(CredentialUpdateRequest)); + CredentialUpdateResponse_descriptor_ = file->message_type(5); + static const int CredentialUpdateResponse_offsets_[1] = { + }; + CredentialUpdateResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + CredentialUpdateResponse_descriptor_, + CredentialUpdateResponse::default_instance_, + CredentialUpdateResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CredentialUpdateResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CredentialUpdateResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(CredentialUpdateResponse)); + AccountFlagUpdateRequest_descriptor_ = file->message_type(6); + static const int AccountFlagUpdateRequest_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFlagUpdateRequest, account_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFlagUpdateRequest, region_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFlagUpdateRequest, flag_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFlagUpdateRequest, active_), + }; + AccountFlagUpdateRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AccountFlagUpdateRequest_descriptor_, + AccountFlagUpdateRequest::default_instance_, + AccountFlagUpdateRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFlagUpdateRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFlagUpdateRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AccountFlagUpdateRequest)); + GameAccountFlagUpdateRequest_descriptor_ = file->message_type(7); + static const int GameAccountFlagUpdateRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFlagUpdateRequest, game_account_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFlagUpdateRequest, flag_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFlagUpdateRequest, active_), + }; + GameAccountFlagUpdateRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GameAccountFlagUpdateRequest_descriptor_, + GameAccountFlagUpdateRequest::default_instance_, + GameAccountFlagUpdateRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFlagUpdateRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFlagUpdateRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GameAccountFlagUpdateRequest)); + SubscriptionUpdateRequest_descriptor_ = file->message_type(8); + static const int SubscriptionUpdateRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriptionUpdateRequest, ref_), + }; + SubscriptionUpdateRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + SubscriptionUpdateRequest_descriptor_, + SubscriptionUpdateRequest::default_instance_, + SubscriptionUpdateRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriptionUpdateRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriptionUpdateRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(SubscriptionUpdateRequest)); + SubscriptionUpdateResponse_descriptor_ = file->message_type(9); + static const int SubscriptionUpdateResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriptionUpdateResponse, ref_), + }; + SubscriptionUpdateResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + SubscriptionUpdateResponse_descriptor_, + SubscriptionUpdateResponse::default_instance_, + SubscriptionUpdateResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriptionUpdateResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriptionUpdateResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(SubscriptionUpdateResponse)); + IsIgrAddressRequest_descriptor_ = file->message_type(10); + static const int IsIgrAddressRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(IsIgrAddressRequest, client_address_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(IsIgrAddressRequest, region_), + }; + IsIgrAddressRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + IsIgrAddressRequest_descriptor_, + IsIgrAddressRequest::default_instance_, + IsIgrAddressRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(IsIgrAddressRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(IsIgrAddressRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(IsIgrAddressRequest)); + AccountServiceRegion_descriptor_ = file->message_type(11); + static const int AccountServiceRegion_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountServiceRegion, id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountServiceRegion, shard_), + }; + AccountServiceRegion_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AccountServiceRegion_descriptor_, + AccountServiceRegion::default_instance_, + AccountServiceRegion_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountServiceRegion, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountServiceRegion, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AccountServiceRegion)); + AccountServiceConfig_descriptor_ = file->message_type(12); + static const int AccountServiceConfig_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountServiceConfig, region_), + }; + AccountServiceConfig_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AccountServiceConfig_descriptor_, + AccountServiceConfig::default_instance_, + AccountServiceConfig_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountServiceConfig, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountServiceConfig, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AccountServiceConfig)); + GetAccountStateRequest_descriptor_ = file->message_type(13); + static const int GetAccountStateRequest_offsets_[5] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateRequest, entity_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateRequest, program_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateRequest, region_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateRequest, options_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateRequest, tags_), + }; + GetAccountStateRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GetAccountStateRequest_descriptor_, + GetAccountStateRequest::default_instance_, + GetAccountStateRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GetAccountStateRequest)); + GetAccountStateResponse_descriptor_ = file->message_type(14); + static const int GetAccountStateResponse_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateResponse, state_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateResponse, tags_), + }; + GetAccountStateResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GetAccountStateResponse_descriptor_, + GetAccountStateResponse::default_instance_, + GetAccountStateResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GetAccountStateResponse)); + GetGameAccountStateRequest_descriptor_ = file->message_type(15); + static const int GetGameAccountStateRequest_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountStateRequest, account_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountStateRequest, game_account_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountStateRequest, options_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountStateRequest, tags_), + }; + GetGameAccountStateRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GetGameAccountStateRequest_descriptor_, + GetGameAccountStateRequest::default_instance_, + GetGameAccountStateRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountStateRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountStateRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GetGameAccountStateRequest)); + GetGameAccountStateResponse_descriptor_ = file->message_type(16); + static const int GetGameAccountStateResponse_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountStateResponse, state_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountStateResponse, tags_), + }; + GetGameAccountStateResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GetGameAccountStateResponse_descriptor_, + GetGameAccountStateResponse::default_instance_, + GetGameAccountStateResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountStateResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountStateResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GetGameAccountStateResponse)); + GetLicensesRequest_descriptor_ = file->message_type(17); + static const int GetLicensesRequest_offsets_[6] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesRequest, target_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesRequest, fetch_account_licenses_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesRequest, fetch_game_account_licenses_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesRequest, fetch_dynamic_account_licenses_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesRequest, program_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesRequest, exclude_unknown_program_), + }; + GetLicensesRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GetLicensesRequest_descriptor_, + GetLicensesRequest::default_instance_, + GetLicensesRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GetLicensesRequest)); + GetLicensesResponse_descriptor_ = file->message_type(18); + static const int GetLicensesResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesResponse, licenses_), + }; + GetLicensesResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GetLicensesResponse_descriptor_, + GetLicensesResponse::default_instance_, + GetLicensesResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GetLicensesResponse)); + GetGameSessionInfoRequest_descriptor_ = file->message_type(19); + static const int GetGameSessionInfoRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameSessionInfoRequest, entity_id_), + }; + GetGameSessionInfoRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GetGameSessionInfoRequest_descriptor_, + GetGameSessionInfoRequest::default_instance_, + GetGameSessionInfoRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameSessionInfoRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameSessionInfoRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GetGameSessionInfoRequest)); + GetGameSessionInfoResponse_descriptor_ = file->message_type(20); + static const int GetGameSessionInfoResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameSessionInfoResponse, session_info_), + }; + GetGameSessionInfoResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GetGameSessionInfoResponse_descriptor_, + GetGameSessionInfoResponse::default_instance_, + GetGameSessionInfoResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameSessionInfoResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameSessionInfoResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GetGameSessionInfoResponse)); + GetGameTimeRemainingInfoRequest_descriptor_ = file->message_type(21); + static const int GetGameTimeRemainingInfoRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameTimeRemainingInfoRequest, game_account_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameTimeRemainingInfoRequest, account_id_), + }; + GetGameTimeRemainingInfoRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GetGameTimeRemainingInfoRequest_descriptor_, + GetGameTimeRemainingInfoRequest::default_instance_, + GetGameTimeRemainingInfoRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameTimeRemainingInfoRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameTimeRemainingInfoRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GetGameTimeRemainingInfoRequest)); + GetGameTimeRemainingInfoResponse_descriptor_ = file->message_type(22); + static const int GetGameTimeRemainingInfoResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameTimeRemainingInfoResponse, game_time_remaining_info_), + }; + GetGameTimeRemainingInfoResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GetGameTimeRemainingInfoResponse_descriptor_, + GetGameTimeRemainingInfoResponse::default_instance_, + GetGameTimeRemainingInfoResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameTimeRemainingInfoResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameTimeRemainingInfoResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GetGameTimeRemainingInfoResponse)); + GetCAISInfoRequest_descriptor_ = file->message_type(23); + static const int GetCAISInfoRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetCAISInfoRequest, entity_id_), + }; + GetCAISInfoRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GetCAISInfoRequest_descriptor_, + GetCAISInfoRequest::default_instance_, + GetCAISInfoRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetCAISInfoRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetCAISInfoRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GetCAISInfoRequest)); + GetCAISInfoResponse_descriptor_ = file->message_type(24); + static const int GetCAISInfoResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetCAISInfoResponse, cais_info_), + }; + GetCAISInfoResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GetCAISInfoResponse_descriptor_, + GetCAISInfoResponse::default_instance_, + GetCAISInfoResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetCAISInfoResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetCAISInfoResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GetCAISInfoResponse)); + ForwardCacheExpireRequest_descriptor_ = file->message_type(25); + static const int ForwardCacheExpireRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ForwardCacheExpireRequest, entity_id_), + }; + ForwardCacheExpireRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ForwardCacheExpireRequest_descriptor_, + ForwardCacheExpireRequest::default_instance_, + ForwardCacheExpireRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ForwardCacheExpireRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ForwardCacheExpireRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ForwardCacheExpireRequest)); + GetAuthorizedDataRequest_descriptor_ = file->message_type(26); + static const int GetAuthorizedDataRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAuthorizedDataRequest, entity_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAuthorizedDataRequest, tag_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAuthorizedDataRequest, privileged_network_), + }; + GetAuthorizedDataRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GetAuthorizedDataRequest_descriptor_, + GetAuthorizedDataRequest::default_instance_, + GetAuthorizedDataRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAuthorizedDataRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAuthorizedDataRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GetAuthorizedDataRequest)); + GetAuthorizedDataResponse_descriptor_ = file->message_type(27); + static const int GetAuthorizedDataResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAuthorizedDataResponse, data_), + }; + GetAuthorizedDataResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GetAuthorizedDataResponse_descriptor_, + GetAuthorizedDataResponse::default_instance_, + GetAuthorizedDataResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAuthorizedDataResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAuthorizedDataResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GetAuthorizedDataResponse)); + AccountStateNotification_descriptor_ = file->message_type(28); + static const int AccountStateNotification_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountStateNotification, account_state_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountStateNotification, subscriber_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountStateNotification, account_tags_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountStateNotification, subscription_completed_), + }; + AccountStateNotification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AccountStateNotification_descriptor_, + AccountStateNotification::default_instance_, + AccountStateNotification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountStateNotification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountStateNotification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AccountStateNotification)); + GameAccountStateNotification_descriptor_ = file->message_type(29); + static const int GameAccountStateNotification_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountStateNotification, game_account_state_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountStateNotification, subscriber_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountStateNotification, game_account_tags_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountStateNotification, subscription_completed_), + }; + GameAccountStateNotification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GameAccountStateNotification_descriptor_, + GameAccountStateNotification::default_instance_, + GameAccountStateNotification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountStateNotification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountStateNotification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GameAccountStateNotification)); + GameAccountNotification_descriptor_ = file->message_type(30); + static const int GameAccountNotification_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountNotification, game_accounts_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountNotification, subscriber_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountNotification, account_tags_), + }; + GameAccountNotification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GameAccountNotification_descriptor_, + GameAccountNotification::default_instance_, + GameAccountNotification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountNotification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountNotification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GameAccountNotification)); + GameAccountSessionNotification_descriptor_ = file->message_type(31); + static const int GameAccountSessionNotification_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountSessionNotification, game_account_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountSessionNotification, session_info_), + }; + GameAccountSessionNotification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GameAccountSessionNotification_descriptor_, + GameAccountSessionNotification::default_instance_, + GameAccountSessionNotification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountSessionNotification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountSessionNotification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GameAccountSessionNotification)); + AccountService_descriptor_ = file->service(0); + AccountListener_descriptor_ = file->service(1); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_account_5fservice_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GetAccountRequest_descriptor_, &GetAccountRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GetAccountResponse_descriptor_, &GetAccountResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + CreateGameAccountRequest_descriptor_, &CreateGameAccountRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + CacheExpireRequest_descriptor_, &CacheExpireRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + CredentialUpdateRequest_descriptor_, &CredentialUpdateRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + CredentialUpdateResponse_descriptor_, &CredentialUpdateResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AccountFlagUpdateRequest_descriptor_, &AccountFlagUpdateRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GameAccountFlagUpdateRequest_descriptor_, &GameAccountFlagUpdateRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SubscriptionUpdateRequest_descriptor_, &SubscriptionUpdateRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SubscriptionUpdateResponse_descriptor_, &SubscriptionUpdateResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + IsIgrAddressRequest_descriptor_, &IsIgrAddressRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AccountServiceRegion_descriptor_, &AccountServiceRegion::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AccountServiceConfig_descriptor_, &AccountServiceConfig::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GetAccountStateRequest_descriptor_, &GetAccountStateRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GetAccountStateResponse_descriptor_, &GetAccountStateResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GetGameAccountStateRequest_descriptor_, &GetGameAccountStateRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GetGameAccountStateResponse_descriptor_, &GetGameAccountStateResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GetLicensesRequest_descriptor_, &GetLicensesRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GetLicensesResponse_descriptor_, &GetLicensesResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GetGameSessionInfoRequest_descriptor_, &GetGameSessionInfoRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GetGameSessionInfoResponse_descriptor_, &GetGameSessionInfoResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GetGameTimeRemainingInfoRequest_descriptor_, &GetGameTimeRemainingInfoRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GetGameTimeRemainingInfoResponse_descriptor_, &GetGameTimeRemainingInfoResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GetCAISInfoRequest_descriptor_, &GetCAISInfoRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GetCAISInfoResponse_descriptor_, &GetCAISInfoResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ForwardCacheExpireRequest_descriptor_, &ForwardCacheExpireRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GetAuthorizedDataRequest_descriptor_, &GetAuthorizedDataRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GetAuthorizedDataResponse_descriptor_, &GetAuthorizedDataResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AccountStateNotification_descriptor_, &AccountStateNotification::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GameAccountStateNotification_descriptor_, &GameAccountStateNotification::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GameAccountNotification_descriptor_, &GameAccountNotification::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GameAccountSessionNotification_descriptor_, &GameAccountSessionNotification::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_account_5fservice_2eproto() { + delete GetAccountRequest::default_instance_; + delete GetAccountRequest_reflection_; + delete GetAccountResponse::default_instance_; + delete GetAccountResponse_reflection_; + delete CreateGameAccountRequest::default_instance_; + delete CreateGameAccountRequest_reflection_; + delete CacheExpireRequest::default_instance_; + delete CacheExpireRequest_reflection_; + delete CredentialUpdateRequest::default_instance_; + delete CredentialUpdateRequest_reflection_; + delete CredentialUpdateResponse::default_instance_; + delete CredentialUpdateResponse_reflection_; + delete AccountFlagUpdateRequest::default_instance_; + delete AccountFlagUpdateRequest_reflection_; + delete GameAccountFlagUpdateRequest::default_instance_; + delete GameAccountFlagUpdateRequest_reflection_; + delete SubscriptionUpdateRequest::default_instance_; + delete SubscriptionUpdateRequest_reflection_; + delete SubscriptionUpdateResponse::default_instance_; + delete SubscriptionUpdateResponse_reflection_; + delete IsIgrAddressRequest::default_instance_; + delete IsIgrAddressRequest_reflection_; + delete AccountServiceRegion::default_instance_; + delete AccountServiceRegion_reflection_; + delete AccountServiceConfig::default_instance_; + delete AccountServiceConfig_reflection_; + delete GetAccountStateRequest::default_instance_; + delete GetAccountStateRequest_reflection_; + delete GetAccountStateResponse::default_instance_; + delete GetAccountStateResponse_reflection_; + delete GetGameAccountStateRequest::default_instance_; + delete GetGameAccountStateRequest_reflection_; + delete GetGameAccountStateResponse::default_instance_; + delete GetGameAccountStateResponse_reflection_; + delete GetLicensesRequest::default_instance_; + delete GetLicensesRequest_reflection_; + delete GetLicensesResponse::default_instance_; + delete GetLicensesResponse_reflection_; + delete GetGameSessionInfoRequest::default_instance_; + delete GetGameSessionInfoRequest_reflection_; + delete GetGameSessionInfoResponse::default_instance_; + delete GetGameSessionInfoResponse_reflection_; + delete GetGameTimeRemainingInfoRequest::default_instance_; + delete GetGameTimeRemainingInfoRequest_reflection_; + delete GetGameTimeRemainingInfoResponse::default_instance_; + delete GetGameTimeRemainingInfoResponse_reflection_; + delete GetCAISInfoRequest::default_instance_; + delete GetCAISInfoRequest_reflection_; + delete GetCAISInfoResponse::default_instance_; + delete GetCAISInfoResponse_reflection_; + delete ForwardCacheExpireRequest::default_instance_; + delete ForwardCacheExpireRequest_reflection_; + delete GetAuthorizedDataRequest::default_instance_; + delete GetAuthorizedDataRequest_reflection_; + delete GetAuthorizedDataResponse::default_instance_; + delete GetAuthorizedDataResponse_reflection_; + delete AccountStateNotification::default_instance_; + delete AccountStateNotification_reflection_; + delete GameAccountStateNotification::default_instance_; + delete GameAccountStateNotification_reflection_; + delete GameAccountNotification::default_instance_; + delete GameAccountNotification_reflection_; + delete GameAccountSessionNotification::default_instance_; + delete GameAccountSessionNotification_reflection_; +} + +void protobuf_AddDesc_account_5fservice_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::bgs::protocol::account::v1::protobuf_AddDesc_account_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\025account_service.proto\022\027bgs.protocol.ac" + "count.v1\032\023account_types.proto\032\022entity_ty" + "pes.proto\032\017rpc_types.proto\"\272\002\n\021GetAccoun" + "tRequest\0226\n\003ref\030\001 \001(\0132).bgs.protocol.acc" + "ount.v1.AccountReference\022\030\n\tfetch_all\030\n " + "\001(\010:\005false\022\031\n\nfetch_blob\030\013 \001(\010:\005false\022\027\n" + "\010fetch_id\030\014 \001(\010:\005false\022\032\n\013fetch_email\030\r " + "\001(\010:\005false\022\037\n\020fetch_battle_tag\030\016 \001(\010:\005fa" + "lse\022\036\n\017fetch_full_name\030\017 \001(\010:\005false\022\032\n\013f" + "etch_links\030\020 \001(\010:\005false\022&\n\027fetch_parenta" + "l_controls\030\021 \001(\010:\005false\"\264\002\n\022GetAccountRe" + "sponse\0222\n\004blob\030\013 \001(\0132$.bgs.protocol.acco" + "unt.v1.AccountBlob\022.\n\002id\030\014 \001(\0132\".bgs.pro" + "tocol.account.v1.AccountId\022\r\n\005email\030\r \003(" + "\t\022\022\n\nbattle_tag\030\016 \001(\t\022\021\n\tfull_name\030\017 \001(\t" + "\0227\n\005links\030\020 \003(\0132(.bgs.protocol.account.v" + "1.GameAccountLink\022K\n\025parental_control_in" + "fo\030\021 \001(\0132,.bgs.protocol.account.v1.Paren" + "talControlInfo\"\216\001\n\030CreateGameAccountRequ" + "est\0223\n\007account\030\001 \001(\0132\".bgs.protocol.acco" + "unt.v1.AccountId\022\016\n\006region\030\002 \001(\r\022\017\n\007prog" + "ram\030\003 \001(\007\022\034\n\021realm_permissions\030\004 \001(\r:\0011\"" + "\232\001\n\022CacheExpireRequest\0223\n\007account\030\001 \003(\0132" + "\".bgs.protocol.account.v1.AccountId\022@\n\014g" + "ame_account\030\002 \003(\0132*.bgs.protocol.account" + ".v1.GameAccountHandle\022\r\n\005email\030\003 \003(\t\"\350\001\n" + "\027CredentialUpdateRequest\0223\n\007account\030\001 \002(" + "\0132\".bgs.protocol.account.v1.AccountId\022C\n" + "\017old_credentials\030\002 \003(\0132*.bgs.protocol.ac" + "count.v1.AccountCredential\022C\n\017new_creden" + "tials\030\003 \003(\0132*.bgs.protocol.account.v1.Ac" + "countCredential\022\016\n\006region\030\004 \001(\r\"\032\n\030Crede" + "ntialUpdateResponse\"}\n\030AccountFlagUpdate" + "Request\0223\n\007account\030\001 \001(\0132\".bgs.protocol." + "account.v1.AccountId\022\016\n\006region\030\002 \001(\r\022\014\n\004" + "flag\030\003 \001(\004\022\016\n\006active\030\004 \001(\010\"~\n\034GameAccoun" + "tFlagUpdateRequest\022@\n\014game_account\030\001 \001(\013" + "2*.bgs.protocol.account.v1.GameAccountHa" + "ndle\022\014\n\004flag\030\002 \001(\004\022\016\n\006active\030\003 \001(\010\"V\n\031Su" + "bscriptionUpdateRequest\0229\n\003ref\030\002 \003(\0132,.b" + "gs.protocol.account.v1.SubscriberReferen" + "ce\"W\n\032SubscriptionUpdateResponse\0229\n\003ref\030" + "\001 \003(\0132,.bgs.protocol.account.v1.Subscrib" + "erReference\"=\n\023IsIgrAddressRequest\022\026\n\016cl" + "ient_address\030\001 \001(\t\022\016\n\006region\030\002 \001(\r\"1\n\024Ac" + "countServiceRegion\022\n\n\002id\030\001 \002(\r\022\r\n\005shard\030" + "\002 \002(\t\"U\n\024AccountServiceConfig\022=\n\006region\030" + "\001 \003(\0132-.bgs.protocol.account.v1.AccountS" + "erviceRegion\"\334\001\n\026GetAccountStateRequest\022" + ")\n\tentity_id\030\001 \001(\0132\026.bgs.protocol.Entity" + "Id\022\017\n\007program\030\002 \001(\r\022\016\n\006region\030\003 \001(\r\022=\n\007o" + "ptions\030\n \001(\0132,.bgs.protocol.account.v1.A" + "ccountFieldOptions\0227\n\004tags\030\013 \001(\0132).bgs.p" + "rotocol.account.v1.AccountFieldTags\"\210\001\n\027" + "GetAccountStateResponse\0224\n\005state\030\001 \001(\0132%" + ".bgs.protocol.account.v1.AccountState\0227\n" + "\004tags\030\002 \001(\0132).bgs.protocol.account.v1.Ac" + "countFieldTags\"\375\001\n\032GetGameAccountStateRe" + "quest\022.\n\naccount_id\030\001 \001(\0132\026.bgs.protocol" + ".EntityIdB\002\030\001\022/\n\017game_account_id\030\002 \001(\0132\026" + ".bgs.protocol.EntityId\022A\n\007options\030\n \001(\0132" + "0.bgs.protocol.account.v1.GameAccountFie" + "ldOptions\022;\n\004tags\030\013 \001(\0132-.bgs.protocol.a" + "ccount.v1.GameAccountFieldTags\"\224\001\n\033GetGa" + "meAccountStateResponse\0228\n\005state\030\001 \001(\0132)." + "bgs.protocol.account.v1.GameAccountState" + "\022;\n\004tags\030\002 \001(\0132-.bgs.protocol.account.v1" + ".GameAccountFieldTags\"\345\001\n\022GetLicensesReq" + "uest\022)\n\ttarget_id\030\001 \001(\0132\026.bgs.protocol.E" + "ntityId\022\036\n\026fetch_account_licenses\030\002 \001(\010\022" + "#\n\033fetch_game_account_licenses\030\003 \001(\010\022&\n\036" + "fetch_dynamic_account_licenses\030\004 \001(\010\022\017\n\007" + "program\030\005 \001(\007\022&\n\027exclude_unknown_program" + "\030\006 \001(\010:\005false\"P\n\023GetLicensesResponse\0229\n\010" + "licenses\030\001 \003(\0132\'.bgs.protocol.account.v1" + ".AccountLicense\"F\n\031GetGameSessionInfoReq" + "uest\022)\n\tentity_id\030\001 \001(\0132\026.bgs.protocol.E" + "ntityId\"\\\n\032GetGameSessionInfoResponse\022>\n" + "\014session_info\030\002 \001(\0132(.bgs.protocol.accou" + "nt.v1.GameSessionInfo\"~\n\037GetGameTimeRema" + "iningInfoRequest\022/\n\017game_account_id\030\001 \001(" + "\0132\026.bgs.protocol.EntityId\022*\n\naccount_id\030" + "\002 \001(\0132\026.bgs.protocol.EntityId\"t\n GetGame" + "TimeRemainingInfoResponse\022P\n\030game_time_r" + "emaining_info\030\001 \001(\0132..bgs.protocol.accou" + "nt.v1.GameTimeRemainingInfo\"\?\n\022GetCAISIn" + "foRequest\022)\n\tentity_id\030\001 \001(\0132\026.bgs.proto" + "col.EntityId\"G\n\023GetCAISInfoResponse\0220\n\tc" + "ais_info\030\001 \001(\0132\035.bgs.protocol.account.v1" + ".CAIS\"F\n\031ForwardCacheExpireRequest\022)\n\ten" + "tity_id\030\001 \001(\0132\026.bgs.protocol.EntityId\"n\n" + "\030GetAuthorizedDataRequest\022)\n\tentity_id\030\001" + " \001(\0132\026.bgs.protocol.EntityId\022\013\n\003tag\030\002 \003(" + "\t\022\032\n\022privileged_network\030\003 \001(\010\"R\n\031GetAuth" + "orizedDataResponse\0225\n\004data\030\001 \003(\0132\'.bgs.p" + "rotocol.account.v1.AuthorizedData\"\320\001\n\030Ac" + "countStateNotification\022<\n\raccount_state\030" + "\001 \001(\0132%.bgs.protocol.account.v1.AccountS" + "tate\022\025\n\rsubscriber_id\030\002 \001(\004\022\?\n\014account_t" + "ags\030\003 \001(\0132).bgs.protocol.account.v1.Acco" + "untFieldTags\022\036\n\026subscription_completed\030\004" + " \001(\010\"\346\001\n\034GameAccountStateNotification\022E\n" + "\022game_account_state\030\001 \001(\0132).bgs.protocol" + ".account.v1.GameAccountState\022\025\n\rsubscrib" + "er_id\030\002 \001(\004\022H\n\021game_account_tags\030\003 \001(\0132-" + ".bgs.protocol.account.v1.GameAccountFiel" + "dTags\022\036\n\026subscription_completed\030\004 \001(\010\"\262\001" + "\n\027GameAccountNotification\022\?\n\rgame_accoun" + "ts\030\001 \003(\0132(.bgs.protocol.account.v1.GameA" + "ccountList\022\025\n\rsubscriber_id\030\002 \001(\004\022\?\n\014acc" + "ount_tags\030\003 \001(\0132).bgs.protocol.account.v" + "1.AccountFieldTags\"\250\001\n\036GameAccountSessio" + "nNotification\022@\n\014game_account\030\001 \001(\0132*.bg" + "s.protocol.account.v1.GameAccountHandle\022" + "D\n\014session_info\030\002 \001(\0132..bgs.protocol.acc" + "ount.v1.GameSessionUpdateInfo2\345\020\n\016Accoun" + "tService\022l\n\016GetGameAccount\022*.bgs.protoco" + "l.account.v1.GameAccountHandle\032(.bgs.pro" + "tocol.account.v1.GameAccountBlob\"\004\200\265\030\014\022k" + "\n\nGetAccount\022*.bgs.protocol.account.v1.G" + "etAccountRequest\032+.bgs.protocol.account." + "v1.GetAccountResponse\"\004\200\265\030\r\022x\n\021CreateGam" + "eAccount\0221.bgs.protocol.account.v1.Creat" + "eGameAccountRequest\032*.bgs.protocol.accou" + "nt.v1.GameAccountHandle\"\004\200\265\030\016\022X\n\014IsIgrAd" + "dress\022,.bgs.protocol.account.v1.IsIgrAdd" + "ressRequest\032\024.bgs.protocol.NoData\"\004\200\265\030\017\022" + "[\n\013CacheExpire\022+.bgs.protocol.account.v1" + ".CacheExpireRequest\032\031.bgs.protocol.NO_RE" + "SPONSE\"\004\200\265\030\024\022}\n\020CredentialUpdate\0220.bgs.p" + "rotocol.account.v1.CredentialUpdateReque" + "st\0321.bgs.protocol.account.v1.CredentialU" + "pdateResponse\"\004\200\265\030\025\022z\n\tSubscribe\0222.bgs.p" + "rotocol.account.v1.SubscriptionUpdateReq" + "uest\0323.bgs.protocol.account.v1.Subscript" + "ionUpdateResponse\"\004\200\265\030\031\022]\n\013Unsubscribe\0222" + ".bgs.protocol.account.v1.SubscriptionUpd" + "ateRequest\032\024.bgs.protocol.NoData\"\004\200\265\030\032\022z" + "\n\017GetAccountState\022/.bgs.protocol.account" + ".v1.GetAccountStateRequest\0320.bgs.protoco" + "l.account.v1.GetAccountStateResponse\"\004\200\265" + "\030\036\022\206\001\n\023GetGameAccountState\0223.bgs.protoco" + "l.account.v1.GetGameAccountStateRequest\032" + "4.bgs.protocol.account.v1.GetGameAccount" + "StateResponse\"\004\200\265\030\037\022n\n\013GetLicenses\022+.bgs" + ".protocol.account.v1.GetLicensesRequest\032" + ",.bgs.protocol.account.v1.GetLicensesRes" + "ponse\"\004\200\265\030 \022\225\001\n\030GetGameTimeRemainingInfo" + "\0228.bgs.protocol.account.v1.GetGameTimeRe" + "mainingInfoRequest\0329.bgs.protocol.accoun" + "t.v1.GetGameTimeRemainingInfoResponse\"\004\200" + "\265\030!\022\203\001\n\022GetGameSessionInfo\0222.bgs.protoco" + "l.account.v1.GetGameSessionInfoRequest\0323" + ".bgs.protocol.account.v1.GetGameSessionI" + "nfoResponse\"\004\200\265\030\"\022n\n\013GetCAISInfo\022+.bgs.p" + "rotocol.account.v1.GetCAISInfoRequest\032,." + "bgs.protocol.account.v1.GetCAISInfoRespo" + "nse\"\004\200\265\030#\022d\n\022ForwardCacheExpire\0222.bgs.pr" + "otocol.account.v1.ForwardCacheExpireRequ" + "est\032\024.bgs.protocol.NoData\"\004\200\265\030$\022\200\001\n\021GetA" + "uthorizedData\0221.bgs.protocol.account.v1." + "GetAuthorizedDataRequest\0322.bgs.protocol." + "account.v1.GetAuthorizedDataResponse\"\004\200\265" + "\030%\022g\n\021AccountFlagUpdate\0221.bgs.protocol.a" + "ccount.v1.AccountFlagUpdateRequest\032\031.bgs" + ".protocol.NO_RESPONSE\"\004\200\265\030&\022o\n\025GameAccou" + "ntFlagUpdate\0225.bgs.protocol.account.v1.G" + "ameAccountFlagUpdateRequest\032\031.bgs.protoc" + "ol.NO_RESPONSE\"\004\200\265\030\'\032\'\312>$bnet.protocol.a" + "ccount.AccountService2\377\003\n\017AccountListene" + "r\022k\n\025OnAccountStateUpdated\0221.bgs.protoco" + "l.account.v1.AccountStateNotification\032\031." + "bgs.protocol.NO_RESPONSE\"\004\200\265\030\001\022s\n\031OnGame" + "AccountStateUpdated\0225.bgs.protocol.accou" + "nt.v1.GameAccountStateNotification\032\031.bgs" + ".protocol.NO_RESPONSE\"\004\200\265\030\002\022m\n\025OnGameAcc" + "ountsUpdated\0220.bgs.protocol.account.v1.G" + "ameAccountNotification\032\031.bgs.protocol.NO" + "_RESPONSE\"\007\210\002\001\200\265\030\003\022s\n\024OnGameSessionUpdat" + "ed\0227.bgs.protocol.account.v1.GameAccount" + "SessionNotification\032\031.bgs.protocol.NO_RE" + "SPONSE\"\007\210\002\001\200\265\030\004\032&\312>#bnet.protocol.accoun" + "t.AccountNotifyB\005H\001\200\001\000", 7302); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "account_service.proto", &protobuf_RegisterTypes); + GetAccountRequest::default_instance_ = new GetAccountRequest(); + GetAccountResponse::default_instance_ = new GetAccountResponse(); + CreateGameAccountRequest::default_instance_ = new CreateGameAccountRequest(); + CacheExpireRequest::default_instance_ = new CacheExpireRequest(); + CredentialUpdateRequest::default_instance_ = new CredentialUpdateRequest(); + CredentialUpdateResponse::default_instance_ = new CredentialUpdateResponse(); + AccountFlagUpdateRequest::default_instance_ = new AccountFlagUpdateRequest(); + GameAccountFlagUpdateRequest::default_instance_ = new GameAccountFlagUpdateRequest(); + SubscriptionUpdateRequest::default_instance_ = new SubscriptionUpdateRequest(); + SubscriptionUpdateResponse::default_instance_ = new SubscriptionUpdateResponse(); + IsIgrAddressRequest::default_instance_ = new IsIgrAddressRequest(); + AccountServiceRegion::default_instance_ = new AccountServiceRegion(); + AccountServiceConfig::default_instance_ = new AccountServiceConfig(); + GetAccountStateRequest::default_instance_ = new GetAccountStateRequest(); + GetAccountStateResponse::default_instance_ = new GetAccountStateResponse(); + GetGameAccountStateRequest::default_instance_ = new GetGameAccountStateRequest(); + GetGameAccountStateResponse::default_instance_ = new GetGameAccountStateResponse(); + GetLicensesRequest::default_instance_ = new GetLicensesRequest(); + GetLicensesResponse::default_instance_ = new GetLicensesResponse(); + GetGameSessionInfoRequest::default_instance_ = new GetGameSessionInfoRequest(); + GetGameSessionInfoResponse::default_instance_ = new GetGameSessionInfoResponse(); + GetGameTimeRemainingInfoRequest::default_instance_ = new GetGameTimeRemainingInfoRequest(); + GetGameTimeRemainingInfoResponse::default_instance_ = new GetGameTimeRemainingInfoResponse(); + GetCAISInfoRequest::default_instance_ = new GetCAISInfoRequest(); + GetCAISInfoResponse::default_instance_ = new GetCAISInfoResponse(); + ForwardCacheExpireRequest::default_instance_ = new ForwardCacheExpireRequest(); + GetAuthorizedDataRequest::default_instance_ = new GetAuthorizedDataRequest(); + GetAuthorizedDataResponse::default_instance_ = new GetAuthorizedDataResponse(); + AccountStateNotification::default_instance_ = new AccountStateNotification(); + GameAccountStateNotification::default_instance_ = new GameAccountStateNotification(); + GameAccountNotification::default_instance_ = new GameAccountNotification(); + GameAccountSessionNotification::default_instance_ = new GameAccountSessionNotification(); + GetAccountRequest::default_instance_->InitAsDefaultInstance(); + GetAccountResponse::default_instance_->InitAsDefaultInstance(); + CreateGameAccountRequest::default_instance_->InitAsDefaultInstance(); + CacheExpireRequest::default_instance_->InitAsDefaultInstance(); + CredentialUpdateRequest::default_instance_->InitAsDefaultInstance(); + CredentialUpdateResponse::default_instance_->InitAsDefaultInstance(); + AccountFlagUpdateRequest::default_instance_->InitAsDefaultInstance(); + GameAccountFlagUpdateRequest::default_instance_->InitAsDefaultInstance(); + SubscriptionUpdateRequest::default_instance_->InitAsDefaultInstance(); + SubscriptionUpdateResponse::default_instance_->InitAsDefaultInstance(); + IsIgrAddressRequest::default_instance_->InitAsDefaultInstance(); + AccountServiceRegion::default_instance_->InitAsDefaultInstance(); + AccountServiceConfig::default_instance_->InitAsDefaultInstance(); + GetAccountStateRequest::default_instance_->InitAsDefaultInstance(); + GetAccountStateResponse::default_instance_->InitAsDefaultInstance(); + GetGameAccountStateRequest::default_instance_->InitAsDefaultInstance(); + GetGameAccountStateResponse::default_instance_->InitAsDefaultInstance(); + GetLicensesRequest::default_instance_->InitAsDefaultInstance(); + GetLicensesResponse::default_instance_->InitAsDefaultInstance(); + GetGameSessionInfoRequest::default_instance_->InitAsDefaultInstance(); + GetGameSessionInfoResponse::default_instance_->InitAsDefaultInstance(); + GetGameTimeRemainingInfoRequest::default_instance_->InitAsDefaultInstance(); + GetGameTimeRemainingInfoResponse::default_instance_->InitAsDefaultInstance(); + GetCAISInfoRequest::default_instance_->InitAsDefaultInstance(); + GetCAISInfoResponse::default_instance_->InitAsDefaultInstance(); + ForwardCacheExpireRequest::default_instance_->InitAsDefaultInstance(); + GetAuthorizedDataRequest::default_instance_->InitAsDefaultInstance(); + GetAuthorizedDataResponse::default_instance_->InitAsDefaultInstance(); + AccountStateNotification::default_instance_->InitAsDefaultInstance(); + GameAccountStateNotification::default_instance_->InitAsDefaultInstance(); + GameAccountNotification::default_instance_->InitAsDefaultInstance(); + GameAccountSessionNotification::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_account_5fservice_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_account_5fservice_2eproto { + StaticDescriptorInitializer_account_5fservice_2eproto() { + protobuf_AddDesc_account_5fservice_2eproto(); + } +} static_descriptor_initializer_account_5fservice_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int GetAccountRequest::kRefFieldNumber; +const int GetAccountRequest::kFetchAllFieldNumber; +const int GetAccountRequest::kFetchBlobFieldNumber; +const int GetAccountRequest::kFetchIdFieldNumber; +const int GetAccountRequest::kFetchEmailFieldNumber; +const int GetAccountRequest::kFetchBattleTagFieldNumber; +const int GetAccountRequest::kFetchFullNameFieldNumber; +const int GetAccountRequest::kFetchLinksFieldNumber; +const int GetAccountRequest::kFetchParentalControlsFieldNumber; +#endif // !_MSC_VER + +GetAccountRequest::GetAccountRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetAccountRequest) +} + +void GetAccountRequest::InitAsDefaultInstance() { + ref_ = const_cast< ::bgs::protocol::account::v1::AccountReference*>(&::bgs::protocol::account::v1::AccountReference::default_instance()); +} + +GetAccountRequest::GetAccountRequest(const GetAccountRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetAccountRequest) +} + +void GetAccountRequest::SharedCtor() { + _cached_size_ = 0; + ref_ = NULL; + fetch_all_ = false; + fetch_blob_ = false; + fetch_id_ = false; + fetch_email_ = false; + fetch_battle_tag_ = false; + fetch_full_name_ = false; + fetch_links_ = false; + fetch_parental_controls_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GetAccountRequest::~GetAccountRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetAccountRequest) + SharedDtor(); +} + +void GetAccountRequest::SharedDtor() { + if (this != default_instance_) { + delete ref_; + } +} + +void GetAccountRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GetAccountRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GetAccountRequest_descriptor_; +} + +const GetAccountRequest& GetAccountRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +GetAccountRequest* GetAccountRequest::default_instance_ = NULL; + +GetAccountRequest* GetAccountRequest::New() const { + return new GetAccountRequest; +} + +void GetAccountRequest::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(fetch_all_, fetch_links_); + if (has_ref()) { + if (ref_ != NULL) ref_->::bgs::protocol::account::v1::AccountReference::Clear(); + } + } + fetch_parental_controls_ = false; + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GetAccountRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetAccountRequest) + 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 .bgs.protocol.account.v1.AccountReference ref = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_ref())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(80)) goto parse_fetch_all; + break; + } + + // optional bool fetch_all = 10 [default = false]; + case 10: { + if (tag == 80) { + parse_fetch_all: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &fetch_all_))); + set_has_fetch_all(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(88)) goto parse_fetch_blob; + break; + } + + // optional bool fetch_blob = 11 [default = false]; + case 11: { + if (tag == 88) { + parse_fetch_blob: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &fetch_blob_))); + set_has_fetch_blob(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(96)) goto parse_fetch_id; + break; + } + + // optional bool fetch_id = 12 [default = false]; + case 12: { + if (tag == 96) { + parse_fetch_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &fetch_id_))); + set_has_fetch_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(104)) goto parse_fetch_email; + break; + } + + // optional bool fetch_email = 13 [default = false]; + case 13: { + if (tag == 104) { + parse_fetch_email: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &fetch_email_))); + set_has_fetch_email(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(112)) goto parse_fetch_battle_tag; + break; + } + + // optional bool fetch_battle_tag = 14 [default = false]; + case 14: { + if (tag == 112) { + parse_fetch_battle_tag: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &fetch_battle_tag_))); + set_has_fetch_battle_tag(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(120)) goto parse_fetch_full_name; + break; + } + + // optional bool fetch_full_name = 15 [default = false]; + case 15: { + if (tag == 120) { + parse_fetch_full_name: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &fetch_full_name_))); + set_has_fetch_full_name(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(128)) goto parse_fetch_links; + break; + } + + // optional bool fetch_links = 16 [default = false]; + case 16: { + if (tag == 128) { + parse_fetch_links: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &fetch_links_))); + set_has_fetch_links(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(136)) goto parse_fetch_parental_controls; + break; + } + + // optional bool fetch_parental_controls = 17 [default = false]; + case 17: { + if (tag == 136) { + parse_fetch_parental_controls: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &fetch_parental_controls_))); + set_has_fetch_parental_controls(); + } 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:bgs.protocol.account.v1.GetAccountRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetAccountRequest) + return false; +#undef DO_ +} + +void GetAccountRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetAccountRequest) + // optional .bgs.protocol.account.v1.AccountReference ref = 1; + if (has_ref()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->ref(), output); + } + + // optional bool fetch_all = 10 [default = false]; + if (has_fetch_all()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(10, this->fetch_all(), output); + } + + // optional bool fetch_blob = 11 [default = false]; + if (has_fetch_blob()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(11, this->fetch_blob(), output); + } + + // optional bool fetch_id = 12 [default = false]; + if (has_fetch_id()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(12, this->fetch_id(), output); + } + + // optional bool fetch_email = 13 [default = false]; + if (has_fetch_email()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(13, this->fetch_email(), output); + } + + // optional bool fetch_battle_tag = 14 [default = false]; + if (has_fetch_battle_tag()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(14, this->fetch_battle_tag(), output); + } + + // optional bool fetch_full_name = 15 [default = false]; + if (has_fetch_full_name()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(15, this->fetch_full_name(), output); + } + + // optional bool fetch_links = 16 [default = false]; + if (has_fetch_links()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(16, this->fetch_links(), output); + } + + // optional bool fetch_parental_controls = 17 [default = false]; + if (has_fetch_parental_controls()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(17, this->fetch_parental_controls(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetAccountRequest) +} + +::google::protobuf::uint8* GetAccountRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetAccountRequest) + // optional .bgs.protocol.account.v1.AccountReference ref = 1; + if (has_ref()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->ref(), target); + } + + // optional bool fetch_all = 10 [default = false]; + if (has_fetch_all()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(10, this->fetch_all(), target); + } + + // optional bool fetch_blob = 11 [default = false]; + if (has_fetch_blob()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(11, this->fetch_blob(), target); + } + + // optional bool fetch_id = 12 [default = false]; + if (has_fetch_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(12, this->fetch_id(), target); + } + + // optional bool fetch_email = 13 [default = false]; + if (has_fetch_email()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(13, this->fetch_email(), target); + } + + // optional bool fetch_battle_tag = 14 [default = false]; + if (has_fetch_battle_tag()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(14, this->fetch_battle_tag(), target); + } + + // optional bool fetch_full_name = 15 [default = false]; + if (has_fetch_full_name()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(15, this->fetch_full_name(), target); + } + + // optional bool fetch_links = 16 [default = false]; + if (has_fetch_links()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(16, this->fetch_links(), target); + } + + // optional bool fetch_parental_controls = 17 [default = false]; + if (has_fetch_parental_controls()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(17, this->fetch_parental_controls(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetAccountRequest) + return target; +} + +int GetAccountRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.account.v1.AccountReference ref = 1; + if (has_ref()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->ref()); + } + + // optional bool fetch_all = 10 [default = false]; + if (has_fetch_all()) { + total_size += 1 + 1; + } + + // optional bool fetch_blob = 11 [default = false]; + if (has_fetch_blob()) { + total_size += 1 + 1; + } + + // optional bool fetch_id = 12 [default = false]; + if (has_fetch_id()) { + total_size += 1 + 1; + } + + // optional bool fetch_email = 13 [default = false]; + if (has_fetch_email()) { + total_size += 1 + 1; + } + + // optional bool fetch_battle_tag = 14 [default = false]; + if (has_fetch_battle_tag()) { + total_size += 1 + 1; + } + + // optional bool fetch_full_name = 15 [default = false]; + if (has_fetch_full_name()) { + total_size += 1 + 1; + } + + // optional bool fetch_links = 16 [default = false]; + if (has_fetch_links()) { + total_size += 2 + 1; + } + + } + if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + // optional bool fetch_parental_controls = 17 [default = false]; + if (has_fetch_parental_controls()) { + 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 GetAccountRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GetAccountRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GetAccountRequest::MergeFrom(const GetAccountRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_ref()) { + mutable_ref()->::bgs::protocol::account::v1::AccountReference::MergeFrom(from.ref()); + } + if (from.has_fetch_all()) { + set_fetch_all(from.fetch_all()); + } + if (from.has_fetch_blob()) { + set_fetch_blob(from.fetch_blob()); + } + if (from.has_fetch_id()) { + set_fetch_id(from.fetch_id()); + } + if (from.has_fetch_email()) { + set_fetch_email(from.fetch_email()); + } + if (from.has_fetch_battle_tag()) { + set_fetch_battle_tag(from.fetch_battle_tag()); + } + if (from.has_fetch_full_name()) { + set_fetch_full_name(from.fetch_full_name()); + } + if (from.has_fetch_links()) { + set_fetch_links(from.fetch_links()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from.has_fetch_parental_controls()) { + set_fetch_parental_controls(from.fetch_parental_controls()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GetAccountRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetAccountRequest::CopyFrom(const GetAccountRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetAccountRequest::IsInitialized() const { + + if (has_ref()) { + if (!this->ref().IsInitialized()) return false; + } + return true; +} + +void GetAccountRequest::Swap(GetAccountRequest* other) { + if (other != this) { + std::swap(ref_, other->ref_); + std::swap(fetch_all_, other->fetch_all_); + std::swap(fetch_blob_, other->fetch_blob_); + std::swap(fetch_id_, other->fetch_id_); + std::swap(fetch_email_, other->fetch_email_); + std::swap(fetch_battle_tag_, other->fetch_battle_tag_); + std::swap(fetch_full_name_, other->fetch_full_name_); + std::swap(fetch_links_, other->fetch_links_); + std::swap(fetch_parental_controls_, other->fetch_parental_controls_); + 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 GetAccountRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GetAccountRequest_descriptor_; + metadata.reflection = GetAccountRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GetAccountResponse::kBlobFieldNumber; +const int GetAccountResponse::kIdFieldNumber; +const int GetAccountResponse::kEmailFieldNumber; +const int GetAccountResponse::kBattleTagFieldNumber; +const int GetAccountResponse::kFullNameFieldNumber; +const int GetAccountResponse::kLinksFieldNumber; +const int GetAccountResponse::kParentalControlInfoFieldNumber; +#endif // !_MSC_VER + +GetAccountResponse::GetAccountResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetAccountResponse) +} + +void GetAccountResponse::InitAsDefaultInstance() { + blob_ = const_cast< ::bgs::protocol::account::v1::AccountBlob*>(&::bgs::protocol::account::v1::AccountBlob::default_instance()); + id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance()); + parental_control_info_ = const_cast< ::bgs::protocol::account::v1::ParentalControlInfo*>(&::bgs::protocol::account::v1::ParentalControlInfo::default_instance()); +} + +GetAccountResponse::GetAccountResponse(const GetAccountResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetAccountResponse) +} + +void GetAccountResponse::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + blob_ = NULL; + id_ = NULL; + battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + parental_control_info_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GetAccountResponse::~GetAccountResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetAccountResponse) + SharedDtor(); +} + +void GetAccountResponse::SharedDtor() { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete battle_tag_; + } + if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete full_name_; + } + if (this != default_instance_) { + delete blob_; + delete id_; + delete parental_control_info_; + } +} + +void GetAccountResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GetAccountResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GetAccountResponse_descriptor_; +} + +const GetAccountResponse& GetAccountResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +GetAccountResponse* GetAccountResponse::default_instance_ = NULL; + +GetAccountResponse* GetAccountResponse::New() const { + return new GetAccountResponse; +} + +void GetAccountResponse::Clear() { + if (_has_bits_[0 / 32] & 91) { + if (has_blob()) { + if (blob_ != NULL) blob_->::bgs::protocol::account::v1::AccountBlob::Clear(); + } + if (has_id()) { + if (id_ != NULL) id_->::bgs::protocol::account::v1::AccountId::Clear(); + } + if (has_battle_tag()) { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_->clear(); + } + } + if (has_full_name()) { + if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + full_name_->clear(); + } + } + if (has_parental_control_info()) { + if (parental_control_info_ != NULL) parental_control_info_->::bgs::protocol::account::v1::ParentalControlInfo::Clear(); + } + } + email_.Clear(); + links_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GetAccountResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetAccountResponse) + 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 .bgs.protocol.account.v1.AccountBlob blob = 11; + case 11: { + if (tag == 90) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_blob())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(98)) goto parse_id; + break; + } + + // optional .bgs.protocol.account.v1.AccountId id = 12; + case 12: { + if (tag == 98) { + parse_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(106)) goto parse_email; + break; + } + + // repeated string email = 13; + case 13: { + if (tag == 106) { + parse_email: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_email())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->email(this->email_size() - 1).data(), + this->email(this->email_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE, + "email"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(106)) goto parse_email; + if (input->ExpectTag(114)) goto parse_battle_tag; + break; + } + + // optional string battle_tag = 14; + case 14: { + if (tag == 114) { + parse_battle_tag: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_battle_tag())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->battle_tag().data(), this->battle_tag().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "battle_tag"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(122)) goto parse_full_name; + break; + } + + // optional string full_name = 15; + case 15: { + if (tag == 122) { + parse_full_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_full_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->full_name().data(), this->full_name().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "full_name"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(130)) goto parse_links; + break; + } + + // repeated .bgs.protocol.account.v1.GameAccountLink links = 16; + case 16: { + if (tag == 130) { + parse_links: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_links())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(130)) goto parse_links; + if (input->ExpectTag(138)) goto parse_parental_control_info; + break; + } + + // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 17; + case 17: { + if (tag == 138) { + parse_parental_control_info: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_parental_control_info())); + } 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:bgs.protocol.account.v1.GetAccountResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetAccountResponse) + return false; +#undef DO_ +} + +void GetAccountResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetAccountResponse) + // optional .bgs.protocol.account.v1.AccountBlob blob = 11; + if (has_blob()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 11, this->blob(), output); + } + + // optional .bgs.protocol.account.v1.AccountId id = 12; + if (has_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 12, this->id(), output); + } + + // repeated string email = 13; + for (int i = 0; i < this->email_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->email(i).data(), this->email(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "email"); + ::google::protobuf::internal::WireFormatLite::WriteString( + 13, this->email(i), output); + } + + // optional string battle_tag = 14; + if (has_battle_tag()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->battle_tag().data(), this->battle_tag().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "battle_tag"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 14, this->battle_tag(), output); + } + + // optional string full_name = 15; + if (has_full_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->full_name().data(), this->full_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "full_name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 15, this->full_name(), output); + } + + // repeated .bgs.protocol.account.v1.GameAccountLink links = 16; + for (int i = 0; i < this->links_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 16, this->links(i), output); + } + + // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 17; + if (has_parental_control_info()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 17, this->parental_control_info(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetAccountResponse) +} + +::google::protobuf::uint8* GetAccountResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetAccountResponse) + // optional .bgs.protocol.account.v1.AccountBlob blob = 11; + if (has_blob()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 11, this->blob(), target); + } + + // optional .bgs.protocol.account.v1.AccountId id = 12; + if (has_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 12, this->id(), target); + } + + // repeated string email = 13; + for (int i = 0; i < this->email_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->email(i).data(), this->email(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "email"); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(13, this->email(i), target); + } + + // optional string battle_tag = 14; + if (has_battle_tag()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->battle_tag().data(), this->battle_tag().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "battle_tag"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 14, this->battle_tag(), target); + } + + // optional string full_name = 15; + if (has_full_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->full_name().data(), this->full_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "full_name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 15, this->full_name(), target); + } + + // repeated .bgs.protocol.account.v1.GameAccountLink links = 16; + for (int i = 0; i < this->links_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 16, this->links(i), target); + } + + // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 17; + if (has_parental_control_info()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 17, this->parental_control_info(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetAccountResponse) + return target; +} + +int GetAccountResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.account.v1.AccountBlob blob = 11; + if (has_blob()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->blob()); + } + + // optional .bgs.protocol.account.v1.AccountId id = 12; + if (has_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->id()); + } + + // optional string battle_tag = 14; + if (has_battle_tag()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->battle_tag()); + } + + // optional string full_name = 15; + if (has_full_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->full_name()); + } + + // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 17; + if (has_parental_control_info()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->parental_control_info()); + } + + } + // repeated string email = 13; + total_size += 1 * this->email_size(); + for (int i = 0; i < this->email_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->email(i)); + } + + // repeated .bgs.protocol.account.v1.GameAccountLink links = 16; + total_size += 2 * this->links_size(); + for (int i = 0; i < this->links_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->links(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 GetAccountResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GetAccountResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GetAccountResponse::MergeFrom(const GetAccountResponse& from) { + GOOGLE_CHECK_NE(&from, this); + email_.MergeFrom(from.email_); + links_.MergeFrom(from.links_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_blob()) { + mutable_blob()->::bgs::protocol::account::v1::AccountBlob::MergeFrom(from.blob()); + } + if (from.has_id()) { + mutable_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.id()); + } + if (from.has_battle_tag()) { + set_battle_tag(from.battle_tag()); + } + if (from.has_full_name()) { + set_full_name(from.full_name()); + } + if (from.has_parental_control_info()) { + mutable_parental_control_info()->::bgs::protocol::account::v1::ParentalControlInfo::MergeFrom(from.parental_control_info()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GetAccountResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetAccountResponse::CopyFrom(const GetAccountResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetAccountResponse::IsInitialized() const { + + if (has_blob()) { + if (!this->blob().IsInitialized()) return false; + } + if (has_id()) { + if (!this->id().IsInitialized()) return false; + } + if (!::google::protobuf::internal::AllAreInitialized(this->links())) return false; + return true; +} + +void GetAccountResponse::Swap(GetAccountResponse* other) { + if (other != this) { + std::swap(blob_, other->blob_); + std::swap(id_, other->id_); + email_.Swap(&other->email_); + std::swap(battle_tag_, other->battle_tag_); + std::swap(full_name_, other->full_name_); + links_.Swap(&other->links_); + std::swap(parental_control_info_, other->parental_control_info_); + 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 GetAccountResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GetAccountResponse_descriptor_; + metadata.reflection = GetAccountResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int CreateGameAccountRequest::kAccountFieldNumber; +const int CreateGameAccountRequest::kRegionFieldNumber; +const int CreateGameAccountRequest::kProgramFieldNumber; +const int CreateGameAccountRequest::kRealmPermissionsFieldNumber; +#endif // !_MSC_VER + +CreateGameAccountRequest::CreateGameAccountRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.CreateGameAccountRequest) +} + +void CreateGameAccountRequest::InitAsDefaultInstance() { + account_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance()); +} + +CreateGameAccountRequest::CreateGameAccountRequest(const CreateGameAccountRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.CreateGameAccountRequest) +} + +void CreateGameAccountRequest::SharedCtor() { + _cached_size_ = 0; + account_ = NULL; + region_ = 0u; + program_ = 0u; + realm_permissions_ = 1u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CreateGameAccountRequest::~CreateGameAccountRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.CreateGameAccountRequest) + SharedDtor(); +} + +void CreateGameAccountRequest::SharedDtor() { + if (this != default_instance_) { + delete account_; + } +} + +void CreateGameAccountRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* CreateGameAccountRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return CreateGameAccountRequest_descriptor_; +} + +const CreateGameAccountRequest& CreateGameAccountRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +CreateGameAccountRequest* CreateGameAccountRequest::default_instance_ = NULL; + +CreateGameAccountRequest* CreateGameAccountRequest::New() const { + return new CreateGameAccountRequest; +} + +void CreateGameAccountRequest::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(region_, program_); + if (has_account()) { + if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear(); + } + realm_permissions_ = 1u; + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool CreateGameAccountRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.CreateGameAccountRequest) + 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 .bgs.protocol.account.v1.AccountId account = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_region; + break; + } + + // optional uint32 region = 2; + case 2: { + if (tag == 16) { + parse_region: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, ®ion_))); + set_has_region(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(29)) goto parse_program; + break; + } + + // optional fixed32 program = 3; + case 3: { + if (tag == 29) { + parse_program: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &program_))); + set_has_program(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_realm_permissions; + break; + } + + // optional uint32 realm_permissions = 4 [default = 1]; + case 4: { + if (tag == 32) { + parse_realm_permissions: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &realm_permissions_))); + set_has_realm_permissions(); + } 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:bgs.protocol.account.v1.CreateGameAccountRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.CreateGameAccountRequest) + return false; +#undef DO_ +} + +void CreateGameAccountRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.CreateGameAccountRequest) + // optional .bgs.protocol.account.v1.AccountId account = 1; + if (has_account()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->account(), output); + } + + // optional uint32 region = 2; + if (has_region()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->region(), output); + } + + // optional fixed32 program = 3; + if (has_program()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->program(), output); + } + + // optional uint32 realm_permissions = 4 [default = 1]; + if (has_realm_permissions()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->realm_permissions(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.CreateGameAccountRequest) +} + +::google::protobuf::uint8* CreateGameAccountRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.CreateGameAccountRequest) + // optional .bgs.protocol.account.v1.AccountId account = 1; + if (has_account()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->account(), target); + } + + // optional uint32 region = 2; + if (has_region()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->region(), target); + } + + // optional fixed32 program = 3; + if (has_program()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->program(), target); + } + + // optional uint32 realm_permissions = 4 [default = 1]; + if (has_realm_permissions()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->realm_permissions(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.CreateGameAccountRequest) + return target; +} + +int CreateGameAccountRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.account.v1.AccountId account = 1; + if (has_account()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account()); + } + + // optional uint32 region = 2; + if (has_region()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->region()); + } + + // optional fixed32 program = 3; + if (has_program()) { + total_size += 1 + 4; + } + + // optional uint32 realm_permissions = 4 [default = 1]; + if (has_realm_permissions()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->realm_permissions()); + } + + } + 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 CreateGameAccountRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const CreateGameAccountRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void CreateGameAccountRequest::MergeFrom(const CreateGameAccountRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_account()) { + mutable_account()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.account()); + } + if (from.has_region()) { + set_region(from.region()); + } + if (from.has_program()) { + set_program(from.program()); + } + if (from.has_realm_permissions()) { + set_realm_permissions(from.realm_permissions()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void CreateGameAccountRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CreateGameAccountRequest::CopyFrom(const CreateGameAccountRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CreateGameAccountRequest::IsInitialized() const { + + if (has_account()) { + if (!this->account().IsInitialized()) return false; + } + return true; +} + +void CreateGameAccountRequest::Swap(CreateGameAccountRequest* other) { + if (other != this) { + std::swap(account_, other->account_); + std::swap(region_, other->region_); + std::swap(program_, other->program_); + std::swap(realm_permissions_, other->realm_permissions_); + 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 CreateGameAccountRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = CreateGameAccountRequest_descriptor_; + metadata.reflection = CreateGameAccountRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int CacheExpireRequest::kAccountFieldNumber; +const int CacheExpireRequest::kGameAccountFieldNumber; +const int CacheExpireRequest::kEmailFieldNumber; +#endif // !_MSC_VER + +CacheExpireRequest::CacheExpireRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.CacheExpireRequest) +} + +void CacheExpireRequest::InitAsDefaultInstance() { +} + +CacheExpireRequest::CacheExpireRequest(const CacheExpireRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.CacheExpireRequest) +} + +void CacheExpireRequest::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CacheExpireRequest::~CacheExpireRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.CacheExpireRequest) + SharedDtor(); +} + +void CacheExpireRequest::SharedDtor() { + if (this != default_instance_) { + } +} + +void CacheExpireRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* CacheExpireRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return CacheExpireRequest_descriptor_; +} + +const CacheExpireRequest& CacheExpireRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +CacheExpireRequest* CacheExpireRequest::default_instance_ = NULL; + +CacheExpireRequest* CacheExpireRequest::New() const { + return new CacheExpireRequest; +} + +void CacheExpireRequest::Clear() { + account_.Clear(); + game_account_.Clear(); + email_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool CacheExpireRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.CacheExpireRequest) + 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 .bgs.protocol.account.v1.AccountId account = 1; + case 1: { + if (tag == 10) { + parse_account: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_account())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_account; + if (input->ExpectTag(18)) goto parse_game_account; + break; + } + + // repeated .bgs.protocol.account.v1.GameAccountHandle game_account = 2; + case 2: { + if (tag == 18) { + parse_game_account: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_game_account())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_game_account; + if (input->ExpectTag(26)) goto parse_email; + break; + } + + // repeated string email = 3; + case 3: { + if (tag == 26) { + parse_email: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_email())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->email(this->email_size() - 1).data(), + this->email(this->email_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE, + "email"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_email; + 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:bgs.protocol.account.v1.CacheExpireRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.CacheExpireRequest) + return false; +#undef DO_ +} + +void CacheExpireRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.CacheExpireRequest) + // repeated .bgs.protocol.account.v1.AccountId account = 1; + for (int i = 0; i < this->account_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->account(i), output); + } + + // repeated .bgs.protocol.account.v1.GameAccountHandle game_account = 2; + for (int i = 0; i < this->game_account_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->game_account(i), output); + } + + // repeated string email = 3; + for (int i = 0; i < this->email_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->email(i).data(), this->email(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "email"); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->email(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.CacheExpireRequest) +} + +::google::protobuf::uint8* CacheExpireRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.CacheExpireRequest) + // repeated .bgs.protocol.account.v1.AccountId account = 1; + for (int i = 0; i < this->account_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->account(i), target); + } + + // repeated .bgs.protocol.account.v1.GameAccountHandle game_account = 2; + for (int i = 0; i < this->game_account_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->game_account(i), target); + } + + // repeated string email = 3; + for (int i = 0; i < this->email_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->email(i).data(), this->email(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "email"); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(3, this->email(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.CacheExpireRequest) + return target; +} + +int CacheExpireRequest::ByteSize() const { + int total_size = 0; + + // repeated .bgs.protocol.account.v1.AccountId account = 1; + total_size += 1 * this->account_size(); + for (int i = 0; i < this->account_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account(i)); + } + + // repeated .bgs.protocol.account.v1.GameAccountHandle game_account = 2; + total_size += 1 * this->game_account_size(); + for (int i = 0; i < this->game_account_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account(i)); + } + + // repeated string email = 3; + total_size += 1 * this->email_size(); + for (int i = 0; i < this->email_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->email(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 CacheExpireRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const CacheExpireRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void CacheExpireRequest::MergeFrom(const CacheExpireRequest& from) { + GOOGLE_CHECK_NE(&from, this); + account_.MergeFrom(from.account_); + game_account_.MergeFrom(from.game_account_); + email_.MergeFrom(from.email_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void CacheExpireRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CacheExpireRequest::CopyFrom(const CacheExpireRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CacheExpireRequest::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->account())) return false; + if (!::google::protobuf::internal::AllAreInitialized(this->game_account())) return false; + return true; +} + +void CacheExpireRequest::Swap(CacheExpireRequest* other) { + if (other != this) { + account_.Swap(&other->account_); + game_account_.Swap(&other->game_account_); + email_.Swap(&other->email_); + 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 CacheExpireRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = CacheExpireRequest_descriptor_; + metadata.reflection = CacheExpireRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int CredentialUpdateRequest::kAccountFieldNumber; +const int CredentialUpdateRequest::kOldCredentialsFieldNumber; +const int CredentialUpdateRequest::kNewCredentialsFieldNumber; +const int CredentialUpdateRequest::kRegionFieldNumber; +#endif // !_MSC_VER + +CredentialUpdateRequest::CredentialUpdateRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.CredentialUpdateRequest) +} + +void CredentialUpdateRequest::InitAsDefaultInstance() { + account_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance()); +} + +CredentialUpdateRequest::CredentialUpdateRequest(const CredentialUpdateRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.CredentialUpdateRequest) +} + +void CredentialUpdateRequest::SharedCtor() { + _cached_size_ = 0; + account_ = NULL; + region_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CredentialUpdateRequest::~CredentialUpdateRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.CredentialUpdateRequest) + SharedDtor(); +} + +void CredentialUpdateRequest::SharedDtor() { + if (this != default_instance_) { + delete account_; + } +} + +void CredentialUpdateRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* CredentialUpdateRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return CredentialUpdateRequest_descriptor_; +} + +const CredentialUpdateRequest& CredentialUpdateRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +CredentialUpdateRequest* CredentialUpdateRequest::default_instance_ = NULL; + +CredentialUpdateRequest* CredentialUpdateRequest::New() const { + return new CredentialUpdateRequest; +} + +void CredentialUpdateRequest::Clear() { + if (_has_bits_[0 / 32] & 9) { + if (has_account()) { + if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear(); + } + region_ = 0u; + } + old_credentials_.Clear(); + new_credentials_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool CredentialUpdateRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.CredentialUpdateRequest) + 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)) { + // required .bgs.protocol.account.v1.AccountId account = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_old_credentials; + break; + } + + // repeated .bgs.protocol.account.v1.AccountCredential old_credentials = 2; + case 2: { + if (tag == 18) { + parse_old_credentials: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_old_credentials())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_old_credentials; + if (input->ExpectTag(26)) goto parse_new_credentials; + break; + } + + // repeated .bgs.protocol.account.v1.AccountCredential new_credentials = 3; + case 3: { + if (tag == 26) { + parse_new_credentials: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_new_credentials())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_new_credentials; + if (input->ExpectTag(32)) goto parse_region; + break; + } + + // optional uint32 region = 4; + case 4: { + if (tag == 32) { + parse_region: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, ®ion_))); + set_has_region(); + } 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:bgs.protocol.account.v1.CredentialUpdateRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.CredentialUpdateRequest) + return false; +#undef DO_ +} + +void CredentialUpdateRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.CredentialUpdateRequest) + // required .bgs.protocol.account.v1.AccountId account = 1; + if (has_account()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->account(), output); + } + + // repeated .bgs.protocol.account.v1.AccountCredential old_credentials = 2; + for (int i = 0; i < this->old_credentials_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->old_credentials(i), output); + } + + // repeated .bgs.protocol.account.v1.AccountCredential new_credentials = 3; + for (int i = 0; i < this->new_credentials_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->new_credentials(i), output); + } + + // optional uint32 region = 4; + if (has_region()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->region(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.CredentialUpdateRequest) +} + +::google::protobuf::uint8* CredentialUpdateRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.CredentialUpdateRequest) + // required .bgs.protocol.account.v1.AccountId account = 1; + if (has_account()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->account(), target); + } + + // repeated .bgs.protocol.account.v1.AccountCredential old_credentials = 2; + for (int i = 0; i < this->old_credentials_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->old_credentials(i), target); + } + + // repeated .bgs.protocol.account.v1.AccountCredential new_credentials = 3; + for (int i = 0; i < this->new_credentials_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->new_credentials(i), target); + } + + // optional uint32 region = 4; + if (has_region()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->region(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.CredentialUpdateRequest) + return target; +} + +int CredentialUpdateRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.account.v1.AccountId account = 1; + if (has_account()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account()); + } + + // optional uint32 region = 4; + if (has_region()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->region()); + } + + } + // repeated .bgs.protocol.account.v1.AccountCredential old_credentials = 2; + total_size += 1 * this->old_credentials_size(); + for (int i = 0; i < this->old_credentials_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->old_credentials(i)); + } + + // repeated .bgs.protocol.account.v1.AccountCredential new_credentials = 3; + total_size += 1 * this->new_credentials_size(); + for (int i = 0; i < this->new_credentials_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->new_credentials(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 CredentialUpdateRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const CredentialUpdateRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void CredentialUpdateRequest::MergeFrom(const CredentialUpdateRequest& from) { + GOOGLE_CHECK_NE(&from, this); + old_credentials_.MergeFrom(from.old_credentials_); + new_credentials_.MergeFrom(from.new_credentials_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_account()) { + mutable_account()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.account()); + } + if (from.has_region()) { + set_region(from.region()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void CredentialUpdateRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CredentialUpdateRequest::CopyFrom(const CredentialUpdateRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CredentialUpdateRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_account()) { + if (!this->account().IsInitialized()) return false; + } + if (!::google::protobuf::internal::AllAreInitialized(this->old_credentials())) return false; + if (!::google::protobuf::internal::AllAreInitialized(this->new_credentials())) return false; + return true; +} + +void CredentialUpdateRequest::Swap(CredentialUpdateRequest* other) { + if (other != this) { + std::swap(account_, other->account_); + old_credentials_.Swap(&other->old_credentials_); + new_credentials_.Swap(&other->new_credentials_); + std::swap(region_, other->region_); + 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 CredentialUpdateRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = CredentialUpdateRequest_descriptor_; + metadata.reflection = CredentialUpdateRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +#endif // !_MSC_VER + +CredentialUpdateResponse::CredentialUpdateResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.CredentialUpdateResponse) +} + +void CredentialUpdateResponse::InitAsDefaultInstance() { +} + +CredentialUpdateResponse::CredentialUpdateResponse(const CredentialUpdateResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.CredentialUpdateResponse) +} + +void CredentialUpdateResponse::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CredentialUpdateResponse::~CredentialUpdateResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.CredentialUpdateResponse) + SharedDtor(); +} + +void CredentialUpdateResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void CredentialUpdateResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* CredentialUpdateResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return CredentialUpdateResponse_descriptor_; +} + +const CredentialUpdateResponse& CredentialUpdateResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +CredentialUpdateResponse* CredentialUpdateResponse::default_instance_ = NULL; + +CredentialUpdateResponse* CredentialUpdateResponse::New() const { + return new CredentialUpdateResponse; +} + +void CredentialUpdateResponse::Clear() { + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool CredentialUpdateResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.CredentialUpdateResponse) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + 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())); + } +success: + // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.CredentialUpdateResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.CredentialUpdateResponse) + return false; +#undef DO_ +} + +void CredentialUpdateResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.CredentialUpdateResponse) + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.CredentialUpdateResponse) +} + +::google::protobuf::uint8* CredentialUpdateResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.CredentialUpdateResponse) + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.CredentialUpdateResponse) + return target; +} + +int CredentialUpdateResponse::ByteSize() const { + int total_size = 0; + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void CredentialUpdateResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const CredentialUpdateResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void CredentialUpdateResponse::MergeFrom(const CredentialUpdateResponse& from) { + GOOGLE_CHECK_NE(&from, this); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void CredentialUpdateResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CredentialUpdateResponse::CopyFrom(const CredentialUpdateResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CredentialUpdateResponse::IsInitialized() const { + + return true; +} + +void CredentialUpdateResponse::Swap(CredentialUpdateResponse* other) { + if (other != this) { + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata CredentialUpdateResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = CredentialUpdateResponse_descriptor_; + metadata.reflection = CredentialUpdateResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AccountFlagUpdateRequest::kAccountFieldNumber; +const int AccountFlagUpdateRequest::kRegionFieldNumber; +const int AccountFlagUpdateRequest::kFlagFieldNumber; +const int AccountFlagUpdateRequest::kActiveFieldNumber; +#endif // !_MSC_VER + +AccountFlagUpdateRequest::AccountFlagUpdateRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountFlagUpdateRequest) +} + +void AccountFlagUpdateRequest::InitAsDefaultInstance() { + account_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance()); +} + +AccountFlagUpdateRequest::AccountFlagUpdateRequest(const AccountFlagUpdateRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountFlagUpdateRequest) +} + +void AccountFlagUpdateRequest::SharedCtor() { + _cached_size_ = 0; + account_ = NULL; + region_ = 0u; + flag_ = GOOGLE_ULONGLONG(0); + active_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AccountFlagUpdateRequest::~AccountFlagUpdateRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountFlagUpdateRequest) + SharedDtor(); +} + +void AccountFlagUpdateRequest::SharedDtor() { + if (this != default_instance_) { + delete account_; + } +} + +void AccountFlagUpdateRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AccountFlagUpdateRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AccountFlagUpdateRequest_descriptor_; +} + +const AccountFlagUpdateRequest& AccountFlagUpdateRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +AccountFlagUpdateRequest* AccountFlagUpdateRequest::default_instance_ = NULL; + +AccountFlagUpdateRequest* AccountFlagUpdateRequest::New() const { + return new AccountFlagUpdateRequest; +} + +void AccountFlagUpdateRequest::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(flag_, active_); + if (has_account()) { + if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear(); + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AccountFlagUpdateRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountFlagUpdateRequest) + 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 .bgs.protocol.account.v1.AccountId account = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_region; + break; + } + + // optional uint32 region = 2; + case 2: { + if (tag == 16) { + parse_region: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, ®ion_))); + set_has_region(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_flag; + break; + } + + // optional uint64 flag = 3; + case 3: { + if (tag == 24) { + parse_flag: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &flag_))); + set_has_flag(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_active; + break; + } + + // optional bool active = 4; + case 4: { + if (tag == 32) { + parse_active: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &active_))); + set_has_active(); + } 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:bgs.protocol.account.v1.AccountFlagUpdateRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountFlagUpdateRequest) + return false; +#undef DO_ +} + +void AccountFlagUpdateRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountFlagUpdateRequest) + // optional .bgs.protocol.account.v1.AccountId account = 1; + if (has_account()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->account(), output); + } + + // optional uint32 region = 2; + if (has_region()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->region(), output); + } + + // optional uint64 flag = 3; + if (has_flag()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->flag(), output); + } + + // optional bool active = 4; + if (has_active()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->active(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountFlagUpdateRequest) +} + +::google::protobuf::uint8* AccountFlagUpdateRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountFlagUpdateRequest) + // optional .bgs.protocol.account.v1.AccountId account = 1; + if (has_account()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->account(), target); + } + + // optional uint32 region = 2; + if (has_region()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->region(), target); + } + + // optional uint64 flag = 3; + if (has_flag()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->flag(), target); + } + + // optional bool active = 4; + if (has_active()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->active(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountFlagUpdateRequest) + return target; +} + +int AccountFlagUpdateRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.account.v1.AccountId account = 1; + if (has_account()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account()); + } + + // optional uint32 region = 2; + if (has_region()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->region()); + } + + // optional uint64 flag = 3; + if (has_flag()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->flag()); + } + + // optional bool active = 4; + if (has_active()) { + 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 AccountFlagUpdateRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AccountFlagUpdateRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AccountFlagUpdateRequest::MergeFrom(const AccountFlagUpdateRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_account()) { + mutable_account()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.account()); + } + if (from.has_region()) { + set_region(from.region()); + } + if (from.has_flag()) { + set_flag(from.flag()); + } + if (from.has_active()) { + set_active(from.active()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AccountFlagUpdateRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AccountFlagUpdateRequest::CopyFrom(const AccountFlagUpdateRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AccountFlagUpdateRequest::IsInitialized() const { + + if (has_account()) { + if (!this->account().IsInitialized()) return false; + } + return true; +} + +void AccountFlagUpdateRequest::Swap(AccountFlagUpdateRequest* other) { + if (other != this) { + std::swap(account_, other->account_); + std::swap(region_, other->region_); + std::swap(flag_, other->flag_); + std::swap(active_, other->active_); + 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 AccountFlagUpdateRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AccountFlagUpdateRequest_descriptor_; + metadata.reflection = AccountFlagUpdateRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GameAccountFlagUpdateRequest::kGameAccountFieldNumber; +const int GameAccountFlagUpdateRequest::kFlagFieldNumber; +const int GameAccountFlagUpdateRequest::kActiveFieldNumber; +#endif // !_MSC_VER + +GameAccountFlagUpdateRequest::GameAccountFlagUpdateRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountFlagUpdateRequest) +} + +void GameAccountFlagUpdateRequest::InitAsDefaultInstance() { + game_account_ = const_cast< ::bgs::protocol::account::v1::GameAccountHandle*>(&::bgs::protocol::account::v1::GameAccountHandle::default_instance()); +} + +GameAccountFlagUpdateRequest::GameAccountFlagUpdateRequest(const GameAccountFlagUpdateRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountFlagUpdateRequest) +} + +void GameAccountFlagUpdateRequest::SharedCtor() { + _cached_size_ = 0; + game_account_ = NULL; + flag_ = GOOGLE_ULONGLONG(0); + active_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameAccountFlagUpdateRequest::~GameAccountFlagUpdateRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountFlagUpdateRequest) + SharedDtor(); +} + +void GameAccountFlagUpdateRequest::SharedDtor() { + if (this != default_instance_) { + delete game_account_; + } +} + +void GameAccountFlagUpdateRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GameAccountFlagUpdateRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GameAccountFlagUpdateRequest_descriptor_; +} + +const GameAccountFlagUpdateRequest& GameAccountFlagUpdateRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +GameAccountFlagUpdateRequest* GameAccountFlagUpdateRequest::default_instance_ = NULL; + +GameAccountFlagUpdateRequest* GameAccountFlagUpdateRequest::New() const { + return new GameAccountFlagUpdateRequest; +} + +void GameAccountFlagUpdateRequest::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(flag_, active_); + if (has_game_account()) { + if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear(); + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GameAccountFlagUpdateRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountFlagUpdateRequest) + 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 .bgs.protocol.account.v1.GameAccountHandle game_account = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_flag; + break; + } + + // optional uint64 flag = 2; + case 2: { + if (tag == 16) { + parse_flag: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &flag_))); + set_has_flag(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_active; + break; + } + + // optional bool active = 3; + case 3: { + if (tag == 24) { + parse_active: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &active_))); + set_has_active(); + } 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:bgs.protocol.account.v1.GameAccountFlagUpdateRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountFlagUpdateRequest) + return false; +#undef DO_ +} + +void GameAccountFlagUpdateRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountFlagUpdateRequest) + // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1; + if (has_game_account()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->game_account(), output); + } + + // optional uint64 flag = 2; + if (has_flag()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->flag(), output); + } + + // optional bool active = 3; + if (has_active()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->active(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountFlagUpdateRequest) +} + +::google::protobuf::uint8* GameAccountFlagUpdateRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountFlagUpdateRequest) + // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1; + if (has_game_account()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->game_account(), target); + } + + // optional uint64 flag = 2; + if (has_flag()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->flag(), target); + } + + // optional bool active = 3; + if (has_active()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->active(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountFlagUpdateRequest) + return target; +} + +int GameAccountFlagUpdateRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1; + if (has_game_account()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account()); + } + + // optional uint64 flag = 2; + if (has_flag()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->flag()); + } + + // optional bool active = 3; + if (has_active()) { + 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 GameAccountFlagUpdateRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GameAccountFlagUpdateRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GameAccountFlagUpdateRequest::MergeFrom(const GameAccountFlagUpdateRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_game_account()) { + mutable_game_account()->::bgs::protocol::account::v1::GameAccountHandle::MergeFrom(from.game_account()); + } + if (from.has_flag()) { + set_flag(from.flag()); + } + if (from.has_active()) { + set_active(from.active()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GameAccountFlagUpdateRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GameAccountFlagUpdateRequest::CopyFrom(const GameAccountFlagUpdateRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameAccountFlagUpdateRequest::IsInitialized() const { + + if (has_game_account()) { + if (!this->game_account().IsInitialized()) return false; + } + return true; +} + +void GameAccountFlagUpdateRequest::Swap(GameAccountFlagUpdateRequest* other) { + if (other != this) { + std::swap(game_account_, other->game_account_); + std::swap(flag_, other->flag_); + std::swap(active_, other->active_); + 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 GameAccountFlagUpdateRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GameAccountFlagUpdateRequest_descriptor_; + metadata.reflection = GameAccountFlagUpdateRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int SubscriptionUpdateRequest::kRefFieldNumber; +#endif // !_MSC_VER + +SubscriptionUpdateRequest::SubscriptionUpdateRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.SubscriptionUpdateRequest) +} + +void SubscriptionUpdateRequest::InitAsDefaultInstance() { +} + +SubscriptionUpdateRequest::SubscriptionUpdateRequest(const SubscriptionUpdateRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.SubscriptionUpdateRequest) +} + +void SubscriptionUpdateRequest::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +SubscriptionUpdateRequest::~SubscriptionUpdateRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.SubscriptionUpdateRequest) + SharedDtor(); +} + +void SubscriptionUpdateRequest::SharedDtor() { + if (this != default_instance_) { + } +} + +void SubscriptionUpdateRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SubscriptionUpdateRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SubscriptionUpdateRequest_descriptor_; +} + +const SubscriptionUpdateRequest& SubscriptionUpdateRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +SubscriptionUpdateRequest* SubscriptionUpdateRequest::default_instance_ = NULL; + +SubscriptionUpdateRequest* SubscriptionUpdateRequest::New() const { + return new SubscriptionUpdateRequest; +} + +void SubscriptionUpdateRequest::Clear() { + ref_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool SubscriptionUpdateRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.SubscriptionUpdateRequest) + 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 .bgs.protocol.account.v1.SubscriberReference ref = 2; + case 2: { + if (tag == 18) { + parse_ref: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_ref())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_ref; + 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:bgs.protocol.account.v1.SubscriptionUpdateRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.SubscriptionUpdateRequest) + return false; +#undef DO_ +} + +void SubscriptionUpdateRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.SubscriptionUpdateRequest) + // repeated .bgs.protocol.account.v1.SubscriberReference ref = 2; + for (int i = 0; i < this->ref_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->ref(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.SubscriptionUpdateRequest) +} + +::google::protobuf::uint8* SubscriptionUpdateRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.SubscriptionUpdateRequest) + // repeated .bgs.protocol.account.v1.SubscriberReference ref = 2; + for (int i = 0; i < this->ref_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->ref(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.SubscriptionUpdateRequest) + return target; +} + +int SubscriptionUpdateRequest::ByteSize() const { + int total_size = 0; + + // repeated .bgs.protocol.account.v1.SubscriberReference ref = 2; + total_size += 1 * this->ref_size(); + for (int i = 0; i < this->ref_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->ref(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 SubscriptionUpdateRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const SubscriptionUpdateRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void SubscriptionUpdateRequest::MergeFrom(const SubscriptionUpdateRequest& from) { + GOOGLE_CHECK_NE(&from, this); + ref_.MergeFrom(from.ref_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void SubscriptionUpdateRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SubscriptionUpdateRequest::CopyFrom(const SubscriptionUpdateRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SubscriptionUpdateRequest::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->ref())) return false; + return true; +} + +void SubscriptionUpdateRequest::Swap(SubscriptionUpdateRequest* other) { + if (other != this) { + ref_.Swap(&other->ref_); + 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 SubscriptionUpdateRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SubscriptionUpdateRequest_descriptor_; + metadata.reflection = SubscriptionUpdateRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int SubscriptionUpdateResponse::kRefFieldNumber; +#endif // !_MSC_VER + +SubscriptionUpdateResponse::SubscriptionUpdateResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.SubscriptionUpdateResponse) +} + +void SubscriptionUpdateResponse::InitAsDefaultInstance() { +} + +SubscriptionUpdateResponse::SubscriptionUpdateResponse(const SubscriptionUpdateResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.SubscriptionUpdateResponse) +} + +void SubscriptionUpdateResponse::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +SubscriptionUpdateResponse::~SubscriptionUpdateResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.SubscriptionUpdateResponse) + SharedDtor(); +} + +void SubscriptionUpdateResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void SubscriptionUpdateResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SubscriptionUpdateResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SubscriptionUpdateResponse_descriptor_; +} + +const SubscriptionUpdateResponse& SubscriptionUpdateResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +SubscriptionUpdateResponse* SubscriptionUpdateResponse::default_instance_ = NULL; + +SubscriptionUpdateResponse* SubscriptionUpdateResponse::New() const { + return new SubscriptionUpdateResponse; +} + +void SubscriptionUpdateResponse::Clear() { + ref_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool SubscriptionUpdateResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.SubscriptionUpdateResponse) + 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 .bgs.protocol.account.v1.SubscriberReference ref = 1; + case 1: { + if (tag == 10) { + parse_ref: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_ref())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_ref; + 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:bgs.protocol.account.v1.SubscriptionUpdateResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.SubscriptionUpdateResponse) + return false; +#undef DO_ +} + +void SubscriptionUpdateResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.SubscriptionUpdateResponse) + // repeated .bgs.protocol.account.v1.SubscriberReference ref = 1; + for (int i = 0; i < this->ref_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->ref(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.SubscriptionUpdateResponse) +} + +::google::protobuf::uint8* SubscriptionUpdateResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.SubscriptionUpdateResponse) + // repeated .bgs.protocol.account.v1.SubscriberReference ref = 1; + for (int i = 0; i < this->ref_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->ref(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.SubscriptionUpdateResponse) + return target; +} + +int SubscriptionUpdateResponse::ByteSize() const { + int total_size = 0; + + // repeated .bgs.protocol.account.v1.SubscriberReference ref = 1; + total_size += 1 * this->ref_size(); + for (int i = 0; i < this->ref_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->ref(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 SubscriptionUpdateResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const SubscriptionUpdateResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void SubscriptionUpdateResponse::MergeFrom(const SubscriptionUpdateResponse& from) { + GOOGLE_CHECK_NE(&from, this); + ref_.MergeFrom(from.ref_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void SubscriptionUpdateResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SubscriptionUpdateResponse::CopyFrom(const SubscriptionUpdateResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SubscriptionUpdateResponse::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->ref())) return false; + return true; +} + +void SubscriptionUpdateResponse::Swap(SubscriptionUpdateResponse* other) { + if (other != this) { + ref_.Swap(&other->ref_); + 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 SubscriptionUpdateResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SubscriptionUpdateResponse_descriptor_; + metadata.reflection = SubscriptionUpdateResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int IsIgrAddressRequest::kClientAddressFieldNumber; +const int IsIgrAddressRequest::kRegionFieldNumber; +#endif // !_MSC_VER + +IsIgrAddressRequest::IsIgrAddressRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.IsIgrAddressRequest) +} + +void IsIgrAddressRequest::InitAsDefaultInstance() { +} + +IsIgrAddressRequest::IsIgrAddressRequest(const IsIgrAddressRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.IsIgrAddressRequest) +} + +void IsIgrAddressRequest::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + client_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + region_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +IsIgrAddressRequest::~IsIgrAddressRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.IsIgrAddressRequest) + SharedDtor(); +} + +void IsIgrAddressRequest::SharedDtor() { + if (client_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete client_address_; + } + if (this != default_instance_) { + } +} + +void IsIgrAddressRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* IsIgrAddressRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return IsIgrAddressRequest_descriptor_; +} + +const IsIgrAddressRequest& IsIgrAddressRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +IsIgrAddressRequest* IsIgrAddressRequest::default_instance_ = NULL; + +IsIgrAddressRequest* IsIgrAddressRequest::New() const { + return new IsIgrAddressRequest; +} + +void IsIgrAddressRequest::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_client_address()) { + if (client_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_address_->clear(); + } + } + region_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool IsIgrAddressRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.IsIgrAddressRequest) + 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 client_address = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_client_address())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->client_address().data(), this->client_address().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "client_address"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_region; + break; + } + + // optional uint32 region = 2; + case 2: { + if (tag == 16) { + parse_region: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, ®ion_))); + set_has_region(); + } 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:bgs.protocol.account.v1.IsIgrAddressRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.IsIgrAddressRequest) + return false; +#undef DO_ +} + +void IsIgrAddressRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.IsIgrAddressRequest) + // optional string client_address = 1; + if (has_client_address()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->client_address().data(), this->client_address().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "client_address"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->client_address(), output); + } + + // optional uint32 region = 2; + if (has_region()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->region(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.IsIgrAddressRequest) +} + +::google::protobuf::uint8* IsIgrAddressRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.IsIgrAddressRequest) + // optional string client_address = 1; + if (has_client_address()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->client_address().data(), this->client_address().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "client_address"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->client_address(), target); + } + + // optional uint32 region = 2; + if (has_region()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->region(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.IsIgrAddressRequest) + return target; +} + +int IsIgrAddressRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional string client_address = 1; + if (has_client_address()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->client_address()); + } + + // optional uint32 region = 2; + if (has_region()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->region()); + } + + } + 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 IsIgrAddressRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const IsIgrAddressRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void IsIgrAddressRequest::MergeFrom(const IsIgrAddressRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_client_address()) { + set_client_address(from.client_address()); + } + if (from.has_region()) { + set_region(from.region()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void IsIgrAddressRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void IsIgrAddressRequest::CopyFrom(const IsIgrAddressRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool IsIgrAddressRequest::IsInitialized() const { + + return true; +} + +void IsIgrAddressRequest::Swap(IsIgrAddressRequest* other) { + if (other != this) { + std::swap(client_address_, other->client_address_); + std::swap(region_, other->region_); + 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 IsIgrAddressRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = IsIgrAddressRequest_descriptor_; + metadata.reflection = IsIgrAddressRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AccountServiceRegion::kIdFieldNumber; +const int AccountServiceRegion::kShardFieldNumber; +#endif // !_MSC_VER + +AccountServiceRegion::AccountServiceRegion() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountServiceRegion) +} + +void AccountServiceRegion::InitAsDefaultInstance() { +} + +AccountServiceRegion::AccountServiceRegion(const AccountServiceRegion& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountServiceRegion) +} + +void AccountServiceRegion::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + id_ = 0u; + shard_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AccountServiceRegion::~AccountServiceRegion() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountServiceRegion) + SharedDtor(); +} + +void AccountServiceRegion::SharedDtor() { + if (shard_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete shard_; + } + if (this != default_instance_) { + } +} + +void AccountServiceRegion::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AccountServiceRegion::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AccountServiceRegion_descriptor_; +} + +const AccountServiceRegion& AccountServiceRegion::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +AccountServiceRegion* AccountServiceRegion::default_instance_ = NULL; + +AccountServiceRegion* AccountServiceRegion::New() const { + return new AccountServiceRegion; +} + +void AccountServiceRegion::Clear() { + if (_has_bits_[0 / 32] & 3) { + id_ = 0u; + if (has_shard()) { + if (shard_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + shard_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AccountServiceRegion::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountServiceRegion) + 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)) { + // required uint32 id = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &id_))); + set_has_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_shard; + break; + } + + // required string shard = 2; + case 2: { + if (tag == 18) { + parse_shard: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_shard())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->shard().data(), this->shard().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "shard"); + } 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:bgs.protocol.account.v1.AccountServiceRegion) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountServiceRegion) + return false; +#undef DO_ +} + +void AccountServiceRegion::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountServiceRegion) + // required uint32 id = 1; + if (has_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->id(), output); + } + + // required string shard = 2; + if (has_shard()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->shard().data(), this->shard().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "shard"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->shard(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountServiceRegion) +} + +::google::protobuf::uint8* AccountServiceRegion::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountServiceRegion) + // required uint32 id = 1; + if (has_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->id(), target); + } + + // required string shard = 2; + if (has_shard()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->shard().data(), this->shard().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "shard"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->shard(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountServiceRegion) + return target; +} + +int AccountServiceRegion::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required uint32 id = 1; + if (has_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->id()); + } + + // required string shard = 2; + if (has_shard()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->shard()); + } + + } + 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 AccountServiceRegion::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AccountServiceRegion* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AccountServiceRegion::MergeFrom(const AccountServiceRegion& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_id()) { + set_id(from.id()); + } + if (from.has_shard()) { + set_shard(from.shard()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AccountServiceRegion::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AccountServiceRegion::CopyFrom(const AccountServiceRegion& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AccountServiceRegion::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void AccountServiceRegion::Swap(AccountServiceRegion* other) { + if (other != this) { + std::swap(id_, other->id_); + std::swap(shard_, other->shard_); + 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 AccountServiceRegion::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AccountServiceRegion_descriptor_; + metadata.reflection = AccountServiceRegion_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AccountServiceConfig::kRegionFieldNumber; +#endif // !_MSC_VER + +AccountServiceConfig::AccountServiceConfig() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountServiceConfig) +} + +void AccountServiceConfig::InitAsDefaultInstance() { +} + +AccountServiceConfig::AccountServiceConfig(const AccountServiceConfig& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountServiceConfig) +} + +void AccountServiceConfig::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AccountServiceConfig::~AccountServiceConfig() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountServiceConfig) + SharedDtor(); +} + +void AccountServiceConfig::SharedDtor() { + if (this != default_instance_) { + } +} + +void AccountServiceConfig::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AccountServiceConfig::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AccountServiceConfig_descriptor_; +} + +const AccountServiceConfig& AccountServiceConfig::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +AccountServiceConfig* AccountServiceConfig::default_instance_ = NULL; + +AccountServiceConfig* AccountServiceConfig::New() const { + return new AccountServiceConfig; +} + +void AccountServiceConfig::Clear() { + region_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AccountServiceConfig::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountServiceConfig) + 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 .bgs.protocol.account.v1.AccountServiceRegion region = 1; + case 1: { + if (tag == 10) { + parse_region: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_region())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_region; + 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:bgs.protocol.account.v1.AccountServiceConfig) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountServiceConfig) + return false; +#undef DO_ +} + +void AccountServiceConfig::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountServiceConfig) + // repeated .bgs.protocol.account.v1.AccountServiceRegion region = 1; + for (int i = 0; i < this->region_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->region(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountServiceConfig) +} + +::google::protobuf::uint8* AccountServiceConfig::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountServiceConfig) + // repeated .bgs.protocol.account.v1.AccountServiceRegion region = 1; + for (int i = 0; i < this->region_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->region(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountServiceConfig) + return target; +} + +int AccountServiceConfig::ByteSize() const { + int total_size = 0; + + // repeated .bgs.protocol.account.v1.AccountServiceRegion region = 1; + total_size += 1 * this->region_size(); + for (int i = 0; i < this->region_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->region(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 AccountServiceConfig::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AccountServiceConfig* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AccountServiceConfig::MergeFrom(const AccountServiceConfig& from) { + GOOGLE_CHECK_NE(&from, this); + region_.MergeFrom(from.region_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AccountServiceConfig::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AccountServiceConfig::CopyFrom(const AccountServiceConfig& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AccountServiceConfig::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->region())) return false; + return true; +} + +void AccountServiceConfig::Swap(AccountServiceConfig* other) { + if (other != this) { + region_.Swap(&other->region_); + 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 AccountServiceConfig::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AccountServiceConfig_descriptor_; + metadata.reflection = AccountServiceConfig_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GetAccountStateRequest::kEntityIdFieldNumber; +const int GetAccountStateRequest::kProgramFieldNumber; +const int GetAccountStateRequest::kRegionFieldNumber; +const int GetAccountStateRequest::kOptionsFieldNumber; +const int GetAccountStateRequest::kTagsFieldNumber; +#endif // !_MSC_VER + +GetAccountStateRequest::GetAccountStateRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetAccountStateRequest) +} + +void GetAccountStateRequest::InitAsDefaultInstance() { + entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + options_ = const_cast< ::bgs::protocol::account::v1::AccountFieldOptions*>(&::bgs::protocol::account::v1::AccountFieldOptions::default_instance()); + tags_ = const_cast< ::bgs::protocol::account::v1::AccountFieldTags*>(&::bgs::protocol::account::v1::AccountFieldTags::default_instance()); +} + +GetAccountStateRequest::GetAccountStateRequest(const GetAccountStateRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetAccountStateRequest) +} + +void GetAccountStateRequest::SharedCtor() { + _cached_size_ = 0; + entity_id_ = NULL; + program_ = 0u; + region_ = 0u; + options_ = NULL; + tags_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GetAccountStateRequest::~GetAccountStateRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetAccountStateRequest) + SharedDtor(); +} + +void GetAccountStateRequest::SharedDtor() { + if (this != default_instance_) { + delete entity_id_; + delete options_; + delete tags_; + } +} + +void GetAccountStateRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GetAccountStateRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GetAccountStateRequest_descriptor_; +} + +const GetAccountStateRequest& GetAccountStateRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +GetAccountStateRequest* GetAccountStateRequest::default_instance_ = NULL; + +GetAccountStateRequest* GetAccountStateRequest::New() const { + return new GetAccountStateRequest; +} + +void GetAccountStateRequest::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(program_, region_); + if (has_entity_id()) { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_options()) { + if (options_ != NULL) options_->::bgs::protocol::account::v1::AccountFieldOptions::Clear(); + } + if (has_tags()) { + if (tags_ != NULL) tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear(); + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GetAccountStateRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetAccountStateRequest) + 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 .bgs.protocol.EntityId entity_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_entity_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_program; + break; + } + + // optional uint32 program = 2; + case 2: { + if (tag == 16) { + parse_program: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &program_))); + set_has_program(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_region; + break; + } + + // optional uint32 region = 3; + case 3: { + if (tag == 24) { + parse_region: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, ®ion_))); + set_has_region(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(82)) goto parse_options; + break; + } + + // optional .bgs.protocol.account.v1.AccountFieldOptions options = 10; + case 10: { + if (tag == 82) { + parse_options: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_options())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(90)) goto parse_tags; + break; + } + + // optional .bgs.protocol.account.v1.AccountFieldTags tags = 11; + case 11: { + if (tag == 90) { + parse_tags: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_tags())); + } 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:bgs.protocol.account.v1.GetAccountStateRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetAccountStateRequest) + return false; +#undef DO_ +} + +void GetAccountStateRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetAccountStateRequest) + // optional .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->entity_id(), output); + } + + // optional uint32 program = 2; + if (has_program()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->program(), output); + } + + // optional uint32 region = 3; + if (has_region()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->region(), output); + } + + // optional .bgs.protocol.account.v1.AccountFieldOptions options = 10; + if (has_options()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 10, this->options(), output); + } + + // optional .bgs.protocol.account.v1.AccountFieldTags tags = 11; + if (has_tags()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 11, this->tags(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetAccountStateRequest) +} + +::google::protobuf::uint8* GetAccountStateRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetAccountStateRequest) + // optional .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->entity_id(), target); + } + + // optional uint32 program = 2; + if (has_program()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->program(), target); + } + + // optional uint32 region = 3; + if (has_region()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->region(), target); + } + + // optional .bgs.protocol.account.v1.AccountFieldOptions options = 10; + if (has_options()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 10, this->options(), target); + } + + // optional .bgs.protocol.account.v1.AccountFieldTags tags = 11; + if (has_tags()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 11, this->tags(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetAccountStateRequest) + return target; +} + +int GetAccountStateRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->entity_id()); + } + + // optional uint32 program = 2; + if (has_program()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->program()); + } + + // optional uint32 region = 3; + if (has_region()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->region()); + } + + // optional .bgs.protocol.account.v1.AccountFieldOptions options = 10; + if (has_options()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->options()); + } + + // optional .bgs.protocol.account.v1.AccountFieldTags tags = 11; + if (has_tags()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->tags()); + } + + } + 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 GetAccountStateRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GetAccountStateRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GetAccountStateRequest::MergeFrom(const GetAccountStateRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_entity_id()) { + mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id()); + } + if (from.has_program()) { + set_program(from.program()); + } + if (from.has_region()) { + set_region(from.region()); + } + if (from.has_options()) { + mutable_options()->::bgs::protocol::account::v1::AccountFieldOptions::MergeFrom(from.options()); + } + if (from.has_tags()) { + mutable_tags()->::bgs::protocol::account::v1::AccountFieldTags::MergeFrom(from.tags()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GetAccountStateRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetAccountStateRequest::CopyFrom(const GetAccountStateRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetAccountStateRequest::IsInitialized() const { + + if (has_entity_id()) { + if (!this->entity_id().IsInitialized()) return false; + } + return true; +} + +void GetAccountStateRequest::Swap(GetAccountStateRequest* other) { + if (other != this) { + std::swap(entity_id_, other->entity_id_); + std::swap(program_, other->program_); + std::swap(region_, other->region_); + std::swap(options_, other->options_); + std::swap(tags_, other->tags_); + 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 GetAccountStateRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GetAccountStateRequest_descriptor_; + metadata.reflection = GetAccountStateRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GetAccountStateResponse::kStateFieldNumber; +const int GetAccountStateResponse::kTagsFieldNumber; +#endif // !_MSC_VER + +GetAccountStateResponse::GetAccountStateResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetAccountStateResponse) +} + +void GetAccountStateResponse::InitAsDefaultInstance() { + state_ = const_cast< ::bgs::protocol::account::v1::AccountState*>(&::bgs::protocol::account::v1::AccountState::default_instance()); + tags_ = const_cast< ::bgs::protocol::account::v1::AccountFieldTags*>(&::bgs::protocol::account::v1::AccountFieldTags::default_instance()); +} + +GetAccountStateResponse::GetAccountStateResponse(const GetAccountStateResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetAccountStateResponse) +} + +void GetAccountStateResponse::SharedCtor() { + _cached_size_ = 0; + state_ = NULL; + tags_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GetAccountStateResponse::~GetAccountStateResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetAccountStateResponse) + SharedDtor(); +} + +void GetAccountStateResponse::SharedDtor() { + if (this != default_instance_) { + delete state_; + delete tags_; + } +} + +void GetAccountStateResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GetAccountStateResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GetAccountStateResponse_descriptor_; +} + +const GetAccountStateResponse& GetAccountStateResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +GetAccountStateResponse* GetAccountStateResponse::default_instance_ = NULL; + +GetAccountStateResponse* GetAccountStateResponse::New() const { + return new GetAccountStateResponse; +} + +void GetAccountStateResponse::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_state()) { + if (state_ != NULL) state_->::bgs::protocol::account::v1::AccountState::Clear(); + } + if (has_tags()) { + if (tags_ != NULL) tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GetAccountStateResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetAccountStateResponse) + 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 .bgs.protocol.account.v1.AccountState state = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_state())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_tags; + break; + } + + // optional .bgs.protocol.account.v1.AccountFieldTags tags = 2; + case 2: { + if (tag == 18) { + parse_tags: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_tags())); + } 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:bgs.protocol.account.v1.GetAccountStateResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetAccountStateResponse) + return false; +#undef DO_ +} + +void GetAccountStateResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetAccountStateResponse) + // optional .bgs.protocol.account.v1.AccountState state = 1; + if (has_state()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->state(), output); + } + + // optional .bgs.protocol.account.v1.AccountFieldTags tags = 2; + if (has_tags()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->tags(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetAccountStateResponse) +} + +::google::protobuf::uint8* GetAccountStateResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetAccountStateResponse) + // optional .bgs.protocol.account.v1.AccountState state = 1; + if (has_state()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->state(), target); + } + + // optional .bgs.protocol.account.v1.AccountFieldTags tags = 2; + if (has_tags()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->tags(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetAccountStateResponse) + return target; +} + +int GetAccountStateResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.account.v1.AccountState state = 1; + if (has_state()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->state()); + } + + // optional .bgs.protocol.account.v1.AccountFieldTags tags = 2; + if (has_tags()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->tags()); + } + + } + 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 GetAccountStateResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GetAccountStateResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GetAccountStateResponse::MergeFrom(const GetAccountStateResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_state()) { + mutable_state()->::bgs::protocol::account::v1::AccountState::MergeFrom(from.state()); + } + if (from.has_tags()) { + mutable_tags()->::bgs::protocol::account::v1::AccountFieldTags::MergeFrom(from.tags()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GetAccountStateResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetAccountStateResponse::CopyFrom(const GetAccountStateResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetAccountStateResponse::IsInitialized() const { + + if (has_state()) { + if (!this->state().IsInitialized()) return false; + } + return true; +} + +void GetAccountStateResponse::Swap(GetAccountStateResponse* other) { + if (other != this) { + std::swap(state_, other->state_); + std::swap(tags_, other->tags_); + 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 GetAccountStateResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GetAccountStateResponse_descriptor_; + metadata.reflection = GetAccountStateResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GetGameAccountStateRequest::kAccountIdFieldNumber; +const int GetGameAccountStateRequest::kGameAccountIdFieldNumber; +const int GetGameAccountStateRequest::kOptionsFieldNumber; +const int GetGameAccountStateRequest::kTagsFieldNumber; +#endif // !_MSC_VER + +GetGameAccountStateRequest::GetGameAccountStateRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetGameAccountStateRequest) +} + +void GetGameAccountStateRequest::InitAsDefaultInstance() { + account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + options_ = const_cast< ::bgs::protocol::account::v1::GameAccountFieldOptions*>(&::bgs::protocol::account::v1::GameAccountFieldOptions::default_instance()); + tags_ = const_cast< ::bgs::protocol::account::v1::GameAccountFieldTags*>(&::bgs::protocol::account::v1::GameAccountFieldTags::default_instance()); +} + +GetGameAccountStateRequest::GetGameAccountStateRequest(const GetGameAccountStateRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetGameAccountStateRequest) +} + +void GetGameAccountStateRequest::SharedCtor() { + _cached_size_ = 0; + account_id_ = NULL; + game_account_id_ = NULL; + options_ = NULL; + tags_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GetGameAccountStateRequest::~GetGameAccountStateRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetGameAccountStateRequest) + SharedDtor(); +} + +void GetGameAccountStateRequest::SharedDtor() { + if (this != default_instance_) { + delete account_id_; + delete game_account_id_; + delete options_; + delete tags_; + } +} + +void GetGameAccountStateRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GetGameAccountStateRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GetGameAccountStateRequest_descriptor_; +} + +const GetGameAccountStateRequest& GetGameAccountStateRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +GetGameAccountStateRequest* GetGameAccountStateRequest::default_instance_ = NULL; + +GetGameAccountStateRequest* GetGameAccountStateRequest::New() const { + return new GetGameAccountStateRequest; +} + +void GetGameAccountStateRequest::Clear() { + if (_has_bits_[0 / 32] & 15) { + if (has_account_id()) { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_game_account_id()) { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_options()) { + if (options_ != NULL) options_->::bgs::protocol::account::v1::GameAccountFieldOptions::Clear(); + } + if (has_tags()) { + if (tags_ != NULL) tags_->::bgs::protocol::account::v1::GameAccountFieldTags::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GetGameAccountStateRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetGameAccountStateRequest) + 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 .bgs.protocol.EntityId account_id = 1 [deprecated = true]; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_game_account_id; + break; + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + case 2: { + if (tag == 18) { + parse_game_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(82)) goto parse_options; + break; + } + + // optional .bgs.protocol.account.v1.GameAccountFieldOptions options = 10; + case 10: { + if (tag == 82) { + parse_options: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_options())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(90)) goto parse_tags; + break; + } + + // optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 11; + case 11: { + if (tag == 90) { + parse_tags: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_tags())); + } 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:bgs.protocol.account.v1.GetGameAccountStateRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetGameAccountStateRequest) + return false; +#undef DO_ +} + +void GetGameAccountStateRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetGameAccountStateRequest) + // optional .bgs.protocol.EntityId account_id = 1 [deprecated = true]; + if (has_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->account_id(), output); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->game_account_id(), output); + } + + // optional .bgs.protocol.account.v1.GameAccountFieldOptions options = 10; + if (has_options()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 10, this->options(), output); + } + + // optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 11; + if (has_tags()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 11, this->tags(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetGameAccountStateRequest) +} + +::google::protobuf::uint8* GetGameAccountStateRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetGameAccountStateRequest) + // optional .bgs.protocol.EntityId account_id = 1 [deprecated = true]; + if (has_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->account_id(), target); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->game_account_id(), target); + } + + // optional .bgs.protocol.account.v1.GameAccountFieldOptions options = 10; + if (has_options()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 10, this->options(), target); + } + + // optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 11; + if (has_tags()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 11, this->tags(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetGameAccountStateRequest) + return target; +} + +int GetGameAccountStateRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId account_id = 1 [deprecated = true]; + if (has_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account_id()); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account_id()); + } + + // optional .bgs.protocol.account.v1.GameAccountFieldOptions options = 10; + if (has_options()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->options()); + } + + // optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 11; + if (has_tags()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->tags()); + } + + } + 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 GetGameAccountStateRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GetGameAccountStateRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GetGameAccountStateRequest::MergeFrom(const GetGameAccountStateRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_account_id()) { + mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id()); + } + if (from.has_game_account_id()) { + mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id()); + } + if (from.has_options()) { + mutable_options()->::bgs::protocol::account::v1::GameAccountFieldOptions::MergeFrom(from.options()); + } + if (from.has_tags()) { + mutable_tags()->::bgs::protocol::account::v1::GameAccountFieldTags::MergeFrom(from.tags()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GetGameAccountStateRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetGameAccountStateRequest::CopyFrom(const GetGameAccountStateRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetGameAccountStateRequest::IsInitialized() const { + + if (has_account_id()) { + if (!this->account_id().IsInitialized()) return false; + } + if (has_game_account_id()) { + if (!this->game_account_id().IsInitialized()) return false; + } + return true; +} + +void GetGameAccountStateRequest::Swap(GetGameAccountStateRequest* other) { + if (other != this) { + std::swap(account_id_, other->account_id_); + std::swap(game_account_id_, other->game_account_id_); + std::swap(options_, other->options_); + std::swap(tags_, other->tags_); + 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 GetGameAccountStateRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GetGameAccountStateRequest_descriptor_; + metadata.reflection = GetGameAccountStateRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GetGameAccountStateResponse::kStateFieldNumber; +const int GetGameAccountStateResponse::kTagsFieldNumber; +#endif // !_MSC_VER + +GetGameAccountStateResponse::GetGameAccountStateResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetGameAccountStateResponse) +} + +void GetGameAccountStateResponse::InitAsDefaultInstance() { + state_ = const_cast< ::bgs::protocol::account::v1::GameAccountState*>(&::bgs::protocol::account::v1::GameAccountState::default_instance()); + tags_ = const_cast< ::bgs::protocol::account::v1::GameAccountFieldTags*>(&::bgs::protocol::account::v1::GameAccountFieldTags::default_instance()); +} + +GetGameAccountStateResponse::GetGameAccountStateResponse(const GetGameAccountStateResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetGameAccountStateResponse) +} + +void GetGameAccountStateResponse::SharedCtor() { + _cached_size_ = 0; + state_ = NULL; + tags_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GetGameAccountStateResponse::~GetGameAccountStateResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetGameAccountStateResponse) + SharedDtor(); +} + +void GetGameAccountStateResponse::SharedDtor() { + if (this != default_instance_) { + delete state_; + delete tags_; + } +} + +void GetGameAccountStateResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GetGameAccountStateResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GetGameAccountStateResponse_descriptor_; +} + +const GetGameAccountStateResponse& GetGameAccountStateResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +GetGameAccountStateResponse* GetGameAccountStateResponse::default_instance_ = NULL; + +GetGameAccountStateResponse* GetGameAccountStateResponse::New() const { + return new GetGameAccountStateResponse; +} + +void GetGameAccountStateResponse::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_state()) { + if (state_ != NULL) state_->::bgs::protocol::account::v1::GameAccountState::Clear(); + } + if (has_tags()) { + if (tags_ != NULL) tags_->::bgs::protocol::account::v1::GameAccountFieldTags::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GetGameAccountStateResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetGameAccountStateResponse) + 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 .bgs.protocol.account.v1.GameAccountState state = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_state())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_tags; + break; + } + + // optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 2; + case 2: { + if (tag == 18) { + parse_tags: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_tags())); + } 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:bgs.protocol.account.v1.GetGameAccountStateResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetGameAccountStateResponse) + return false; +#undef DO_ +} + +void GetGameAccountStateResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetGameAccountStateResponse) + // optional .bgs.protocol.account.v1.GameAccountState state = 1; + if (has_state()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->state(), output); + } + + // optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 2; + if (has_tags()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->tags(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetGameAccountStateResponse) +} + +::google::protobuf::uint8* GetGameAccountStateResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetGameAccountStateResponse) + // optional .bgs.protocol.account.v1.GameAccountState state = 1; + if (has_state()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->state(), target); + } + + // optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 2; + if (has_tags()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->tags(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetGameAccountStateResponse) + return target; +} + +int GetGameAccountStateResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.account.v1.GameAccountState state = 1; + if (has_state()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->state()); + } + + // optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 2; + if (has_tags()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->tags()); + } + + } + 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 GetGameAccountStateResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GetGameAccountStateResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GetGameAccountStateResponse::MergeFrom(const GetGameAccountStateResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_state()) { + mutable_state()->::bgs::protocol::account::v1::GameAccountState::MergeFrom(from.state()); + } + if (from.has_tags()) { + mutable_tags()->::bgs::protocol::account::v1::GameAccountFieldTags::MergeFrom(from.tags()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GetGameAccountStateResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetGameAccountStateResponse::CopyFrom(const GetGameAccountStateResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetGameAccountStateResponse::IsInitialized() const { + + if (has_state()) { + if (!this->state().IsInitialized()) return false; + } + return true; +} + +void GetGameAccountStateResponse::Swap(GetGameAccountStateResponse* other) { + if (other != this) { + std::swap(state_, other->state_); + std::swap(tags_, other->tags_); + 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 GetGameAccountStateResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GetGameAccountStateResponse_descriptor_; + metadata.reflection = GetGameAccountStateResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GetLicensesRequest::kTargetIdFieldNumber; +const int GetLicensesRequest::kFetchAccountLicensesFieldNumber; +const int GetLicensesRequest::kFetchGameAccountLicensesFieldNumber; +const int GetLicensesRequest::kFetchDynamicAccountLicensesFieldNumber; +const int GetLicensesRequest::kProgramFieldNumber; +const int GetLicensesRequest::kExcludeUnknownProgramFieldNumber; +#endif // !_MSC_VER + +GetLicensesRequest::GetLicensesRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetLicensesRequest) +} + +void GetLicensesRequest::InitAsDefaultInstance() { + target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +GetLicensesRequest::GetLicensesRequest(const GetLicensesRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetLicensesRequest) +} + +void GetLicensesRequest::SharedCtor() { + _cached_size_ = 0; + target_id_ = NULL; + fetch_account_licenses_ = false; + fetch_game_account_licenses_ = false; + fetch_dynamic_account_licenses_ = false; + program_ = 0u; + exclude_unknown_program_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GetLicensesRequest::~GetLicensesRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetLicensesRequest) + SharedDtor(); +} + +void GetLicensesRequest::SharedDtor() { + if (this != default_instance_) { + delete target_id_; + } +} + +void GetLicensesRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GetLicensesRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GetLicensesRequest_descriptor_; +} + +const GetLicensesRequest& GetLicensesRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +GetLicensesRequest* GetLicensesRequest::default_instance_ = NULL; + +GetLicensesRequest* GetLicensesRequest::New() const { + return new GetLicensesRequest; +} + +void GetLicensesRequest::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(fetch_account_licenses_, program_); + if (has_target_id()) { + if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear(); + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GetLicensesRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetLicensesRequest) + 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 .bgs.protocol.EntityId target_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_target_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_fetch_account_licenses; + break; + } + + // optional bool fetch_account_licenses = 2; + case 2: { + if (tag == 16) { + parse_fetch_account_licenses: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &fetch_account_licenses_))); + set_has_fetch_account_licenses(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_fetch_game_account_licenses; + break; + } + + // optional bool fetch_game_account_licenses = 3; + case 3: { + if (tag == 24) { + parse_fetch_game_account_licenses: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &fetch_game_account_licenses_))); + set_has_fetch_game_account_licenses(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_fetch_dynamic_account_licenses; + break; + } + + // optional bool fetch_dynamic_account_licenses = 4; + case 4: { + if (tag == 32) { + parse_fetch_dynamic_account_licenses: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &fetch_dynamic_account_licenses_))); + set_has_fetch_dynamic_account_licenses(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(45)) goto parse_program; + break; + } + + // optional fixed32 program = 5; + case 5: { + if (tag == 45) { + parse_program: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &program_))); + set_has_program(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_exclude_unknown_program; + break; + } + + // optional bool exclude_unknown_program = 6 [default = false]; + case 6: { + if (tag == 48) { + parse_exclude_unknown_program: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &exclude_unknown_program_))); + set_has_exclude_unknown_program(); + } 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:bgs.protocol.account.v1.GetLicensesRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetLicensesRequest) + return false; +#undef DO_ +} + +void GetLicensesRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetLicensesRequest) + // optional .bgs.protocol.EntityId target_id = 1; + if (has_target_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->target_id(), output); + } + + // optional bool fetch_account_licenses = 2; + if (has_fetch_account_licenses()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->fetch_account_licenses(), output); + } + + // optional bool fetch_game_account_licenses = 3; + if (has_fetch_game_account_licenses()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->fetch_game_account_licenses(), output); + } + + // optional bool fetch_dynamic_account_licenses = 4; + if (has_fetch_dynamic_account_licenses()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->fetch_dynamic_account_licenses(), output); + } + + // optional fixed32 program = 5; + if (has_program()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->program(), output); + } + + // optional bool exclude_unknown_program = 6 [default = false]; + if (has_exclude_unknown_program()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->exclude_unknown_program(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetLicensesRequest) +} + +::google::protobuf::uint8* GetLicensesRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetLicensesRequest) + // optional .bgs.protocol.EntityId target_id = 1; + if (has_target_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->target_id(), target); + } + + // optional bool fetch_account_licenses = 2; + if (has_fetch_account_licenses()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->fetch_account_licenses(), target); + } + + // optional bool fetch_game_account_licenses = 3; + if (has_fetch_game_account_licenses()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->fetch_game_account_licenses(), target); + } + + // optional bool fetch_dynamic_account_licenses = 4; + if (has_fetch_dynamic_account_licenses()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->fetch_dynamic_account_licenses(), target); + } + + // optional fixed32 program = 5; + if (has_program()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->program(), target); + } + + // optional bool exclude_unknown_program = 6 [default = false]; + if (has_exclude_unknown_program()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->exclude_unknown_program(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetLicensesRequest) + return target; +} + +int GetLicensesRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId target_id = 1; + if (has_target_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->target_id()); + } + + // optional bool fetch_account_licenses = 2; + if (has_fetch_account_licenses()) { + total_size += 1 + 1; + } + + // optional bool fetch_game_account_licenses = 3; + if (has_fetch_game_account_licenses()) { + total_size += 1 + 1; + } + + // optional bool fetch_dynamic_account_licenses = 4; + if (has_fetch_dynamic_account_licenses()) { + total_size += 1 + 1; + } + + // optional fixed32 program = 5; + if (has_program()) { + total_size += 1 + 4; + } + + // optional bool exclude_unknown_program = 6 [default = false]; + if (has_exclude_unknown_program()) { + 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 GetLicensesRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GetLicensesRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GetLicensesRequest::MergeFrom(const GetLicensesRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_target_id()) { + mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id()); + } + if (from.has_fetch_account_licenses()) { + set_fetch_account_licenses(from.fetch_account_licenses()); + } + if (from.has_fetch_game_account_licenses()) { + set_fetch_game_account_licenses(from.fetch_game_account_licenses()); + } + if (from.has_fetch_dynamic_account_licenses()) { + set_fetch_dynamic_account_licenses(from.fetch_dynamic_account_licenses()); + } + if (from.has_program()) { + set_program(from.program()); + } + if (from.has_exclude_unknown_program()) { + set_exclude_unknown_program(from.exclude_unknown_program()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GetLicensesRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetLicensesRequest::CopyFrom(const GetLicensesRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetLicensesRequest::IsInitialized() const { + + if (has_target_id()) { + if (!this->target_id().IsInitialized()) return false; + } + return true; +} + +void GetLicensesRequest::Swap(GetLicensesRequest* other) { + if (other != this) { + std::swap(target_id_, other->target_id_); + std::swap(fetch_account_licenses_, other->fetch_account_licenses_); + std::swap(fetch_game_account_licenses_, other->fetch_game_account_licenses_); + std::swap(fetch_dynamic_account_licenses_, other->fetch_dynamic_account_licenses_); + std::swap(program_, other->program_); + std::swap(exclude_unknown_program_, other->exclude_unknown_program_); + 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 GetLicensesRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GetLicensesRequest_descriptor_; + metadata.reflection = GetLicensesRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GetLicensesResponse::kLicensesFieldNumber; +#endif // !_MSC_VER + +GetLicensesResponse::GetLicensesResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetLicensesResponse) +} + +void GetLicensesResponse::InitAsDefaultInstance() { +} + +GetLicensesResponse::GetLicensesResponse(const GetLicensesResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetLicensesResponse) +} + +void GetLicensesResponse::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GetLicensesResponse::~GetLicensesResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetLicensesResponse) + SharedDtor(); +} + +void GetLicensesResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void GetLicensesResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GetLicensesResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GetLicensesResponse_descriptor_; +} + +const GetLicensesResponse& GetLicensesResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +GetLicensesResponse* GetLicensesResponse::default_instance_ = NULL; + +GetLicensesResponse* GetLicensesResponse::New() const { + return new GetLicensesResponse; +} + +void GetLicensesResponse::Clear() { + licenses_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GetLicensesResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetLicensesResponse) + 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 .bgs.protocol.account.v1.AccountLicense licenses = 1; + case 1: { + if (tag == 10) { + parse_licenses: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_licenses())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_licenses; + 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:bgs.protocol.account.v1.GetLicensesResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetLicensesResponse) + return false; +#undef DO_ +} + +void GetLicensesResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetLicensesResponse) + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 1; + for (int i = 0; i < this->licenses_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->licenses(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetLicensesResponse) +} + +::google::protobuf::uint8* GetLicensesResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetLicensesResponse) + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 1; + for (int i = 0; i < this->licenses_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->licenses(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetLicensesResponse) + return target; +} + +int GetLicensesResponse::ByteSize() const { + int total_size = 0; + + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 1; + total_size += 1 * this->licenses_size(); + for (int i = 0; i < this->licenses_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->licenses(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 GetLicensesResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GetLicensesResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GetLicensesResponse::MergeFrom(const GetLicensesResponse& from) { + GOOGLE_CHECK_NE(&from, this); + licenses_.MergeFrom(from.licenses_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GetLicensesResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetLicensesResponse::CopyFrom(const GetLicensesResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetLicensesResponse::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->licenses())) return false; + return true; +} + +void GetLicensesResponse::Swap(GetLicensesResponse* other) { + if (other != this) { + licenses_.Swap(&other->licenses_); + 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 GetLicensesResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GetLicensesResponse_descriptor_; + metadata.reflection = GetLicensesResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GetGameSessionInfoRequest::kEntityIdFieldNumber; +#endif // !_MSC_VER + +GetGameSessionInfoRequest::GetGameSessionInfoRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetGameSessionInfoRequest) +} + +void GetGameSessionInfoRequest::InitAsDefaultInstance() { + entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +GetGameSessionInfoRequest::GetGameSessionInfoRequest(const GetGameSessionInfoRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetGameSessionInfoRequest) +} + +void GetGameSessionInfoRequest::SharedCtor() { + _cached_size_ = 0; + entity_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GetGameSessionInfoRequest::~GetGameSessionInfoRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetGameSessionInfoRequest) + SharedDtor(); +} + +void GetGameSessionInfoRequest::SharedDtor() { + if (this != default_instance_) { + delete entity_id_; + } +} + +void GetGameSessionInfoRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GetGameSessionInfoRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GetGameSessionInfoRequest_descriptor_; +} + +const GetGameSessionInfoRequest& GetGameSessionInfoRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +GetGameSessionInfoRequest* GetGameSessionInfoRequest::default_instance_ = NULL; + +GetGameSessionInfoRequest* GetGameSessionInfoRequest::New() const { + return new GetGameSessionInfoRequest; +} + +void GetGameSessionInfoRequest::Clear() { + if (has_entity_id()) { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GetGameSessionInfoRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetGameSessionInfoRequest) + 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 .bgs.protocol.EntityId entity_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_entity_id())); + } 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:bgs.protocol.account.v1.GetGameSessionInfoRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetGameSessionInfoRequest) + return false; +#undef DO_ +} + +void GetGameSessionInfoRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetGameSessionInfoRequest) + // optional .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->entity_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetGameSessionInfoRequest) +} + +::google::protobuf::uint8* GetGameSessionInfoRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetGameSessionInfoRequest) + // optional .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->entity_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetGameSessionInfoRequest) + return target; +} + +int GetGameSessionInfoRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->entity_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void GetGameSessionInfoRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GetGameSessionInfoRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GetGameSessionInfoRequest::MergeFrom(const GetGameSessionInfoRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_entity_id()) { + mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GetGameSessionInfoRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetGameSessionInfoRequest::CopyFrom(const GetGameSessionInfoRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetGameSessionInfoRequest::IsInitialized() const { + + if (has_entity_id()) { + if (!this->entity_id().IsInitialized()) return false; + } + return true; +} + +void GetGameSessionInfoRequest::Swap(GetGameSessionInfoRequest* other) { + if (other != this) { + std::swap(entity_id_, other->entity_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata GetGameSessionInfoRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GetGameSessionInfoRequest_descriptor_; + metadata.reflection = GetGameSessionInfoRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GetGameSessionInfoResponse::kSessionInfoFieldNumber; +#endif // !_MSC_VER + +GetGameSessionInfoResponse::GetGameSessionInfoResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetGameSessionInfoResponse) +} + +void GetGameSessionInfoResponse::InitAsDefaultInstance() { + session_info_ = const_cast< ::bgs::protocol::account::v1::GameSessionInfo*>(&::bgs::protocol::account::v1::GameSessionInfo::default_instance()); +} + +GetGameSessionInfoResponse::GetGameSessionInfoResponse(const GetGameSessionInfoResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetGameSessionInfoResponse) +} + +void GetGameSessionInfoResponse::SharedCtor() { + _cached_size_ = 0; + session_info_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GetGameSessionInfoResponse::~GetGameSessionInfoResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetGameSessionInfoResponse) + SharedDtor(); +} + +void GetGameSessionInfoResponse::SharedDtor() { + if (this != default_instance_) { + delete session_info_; + } +} + +void GetGameSessionInfoResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GetGameSessionInfoResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GetGameSessionInfoResponse_descriptor_; +} + +const GetGameSessionInfoResponse& GetGameSessionInfoResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +GetGameSessionInfoResponse* GetGameSessionInfoResponse::default_instance_ = NULL; + +GetGameSessionInfoResponse* GetGameSessionInfoResponse::New() const { + return new GetGameSessionInfoResponse; +} + +void GetGameSessionInfoResponse::Clear() { + if (has_session_info()) { + if (session_info_ != NULL) session_info_->::bgs::protocol::account::v1::GameSessionInfo::Clear(); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GetGameSessionInfoResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetGameSessionInfoResponse) + 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 .bgs.protocol.account.v1.GameSessionInfo session_info = 2; + case 2: { + if (tag == 18) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_session_info())); + } 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:bgs.protocol.account.v1.GetGameSessionInfoResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetGameSessionInfoResponse) + return false; +#undef DO_ +} + +void GetGameSessionInfoResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetGameSessionInfoResponse) + // optional .bgs.protocol.account.v1.GameSessionInfo session_info = 2; + if (has_session_info()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->session_info(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetGameSessionInfoResponse) +} + +::google::protobuf::uint8* GetGameSessionInfoResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetGameSessionInfoResponse) + // optional .bgs.protocol.account.v1.GameSessionInfo session_info = 2; + if (has_session_info()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->session_info(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetGameSessionInfoResponse) + return target; +} + +int GetGameSessionInfoResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.account.v1.GameSessionInfo session_info = 2; + if (has_session_info()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->session_info()); + } + + } + 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 GetGameSessionInfoResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GetGameSessionInfoResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GetGameSessionInfoResponse::MergeFrom(const GetGameSessionInfoResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_session_info()) { + mutable_session_info()->::bgs::protocol::account::v1::GameSessionInfo::MergeFrom(from.session_info()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GetGameSessionInfoResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetGameSessionInfoResponse::CopyFrom(const GetGameSessionInfoResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetGameSessionInfoResponse::IsInitialized() const { + + return true; +} + +void GetGameSessionInfoResponse::Swap(GetGameSessionInfoResponse* other) { + if (other != this) { + std::swap(session_info_, other->session_info_); + 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 GetGameSessionInfoResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GetGameSessionInfoResponse_descriptor_; + metadata.reflection = GetGameSessionInfoResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GetGameTimeRemainingInfoRequest::kGameAccountIdFieldNumber; +const int GetGameTimeRemainingInfoRequest::kAccountIdFieldNumber; +#endif // !_MSC_VER + +GetGameTimeRemainingInfoRequest::GetGameTimeRemainingInfoRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest) +} + +void GetGameTimeRemainingInfoRequest::InitAsDefaultInstance() { + game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +GetGameTimeRemainingInfoRequest::GetGameTimeRemainingInfoRequest(const GetGameTimeRemainingInfoRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest) +} + +void GetGameTimeRemainingInfoRequest::SharedCtor() { + _cached_size_ = 0; + game_account_id_ = NULL; + account_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GetGameTimeRemainingInfoRequest::~GetGameTimeRemainingInfoRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest) + SharedDtor(); +} + +void GetGameTimeRemainingInfoRequest::SharedDtor() { + if (this != default_instance_) { + delete game_account_id_; + delete account_id_; + } +} + +void GetGameTimeRemainingInfoRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GetGameTimeRemainingInfoRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GetGameTimeRemainingInfoRequest_descriptor_; +} + +const GetGameTimeRemainingInfoRequest& GetGameTimeRemainingInfoRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +GetGameTimeRemainingInfoRequest* GetGameTimeRemainingInfoRequest::default_instance_ = NULL; + +GetGameTimeRemainingInfoRequest* GetGameTimeRemainingInfoRequest::New() const { + return new GetGameTimeRemainingInfoRequest; +} + +void GetGameTimeRemainingInfoRequest::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_game_account_id()) { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_account_id()) { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GetGameTimeRemainingInfoRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest) + 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 .bgs.protocol.EntityId game_account_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_account_id; + break; + } + + // optional .bgs.protocol.EntityId account_id = 2; + case 2: { + if (tag == 18) { + parse_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account_id())); + } 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:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest) + return false; +#undef DO_ +} + +void GetGameTimeRemainingInfoRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest) + // optional .bgs.protocol.EntityId game_account_id = 1; + if (has_game_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->game_account_id(), output); + } + + // optional .bgs.protocol.EntityId account_id = 2; + if (has_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->account_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest) +} + +::google::protobuf::uint8* GetGameTimeRemainingInfoRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest) + // optional .bgs.protocol.EntityId game_account_id = 1; + if (has_game_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->game_account_id(), target); + } + + // optional .bgs.protocol.EntityId account_id = 2; + if (has_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->account_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest) + return target; +} + +int GetGameTimeRemainingInfoRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId game_account_id = 1; + if (has_game_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account_id()); + } + + // optional .bgs.protocol.EntityId account_id = 2; + if (has_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void GetGameTimeRemainingInfoRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GetGameTimeRemainingInfoRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GetGameTimeRemainingInfoRequest::MergeFrom(const GetGameTimeRemainingInfoRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_game_account_id()) { + mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id()); + } + if (from.has_account_id()) { + mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GetGameTimeRemainingInfoRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetGameTimeRemainingInfoRequest::CopyFrom(const GetGameTimeRemainingInfoRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetGameTimeRemainingInfoRequest::IsInitialized() const { + + if (has_game_account_id()) { + if (!this->game_account_id().IsInitialized()) return false; + } + if (has_account_id()) { + if (!this->account_id().IsInitialized()) return false; + } + return true; +} + +void GetGameTimeRemainingInfoRequest::Swap(GetGameTimeRemainingInfoRequest* other) { + if (other != this) { + std::swap(game_account_id_, other->game_account_id_); + std::swap(account_id_, other->account_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata GetGameTimeRemainingInfoRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GetGameTimeRemainingInfoRequest_descriptor_; + metadata.reflection = GetGameTimeRemainingInfoRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GetGameTimeRemainingInfoResponse::kGameTimeRemainingInfoFieldNumber; +#endif // !_MSC_VER + +GetGameTimeRemainingInfoResponse::GetGameTimeRemainingInfoResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse) +} + +void GetGameTimeRemainingInfoResponse::InitAsDefaultInstance() { + game_time_remaining_info_ = const_cast< ::bgs::protocol::account::v1::GameTimeRemainingInfo*>(&::bgs::protocol::account::v1::GameTimeRemainingInfo::default_instance()); +} + +GetGameTimeRemainingInfoResponse::GetGameTimeRemainingInfoResponse(const GetGameTimeRemainingInfoResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse) +} + +void GetGameTimeRemainingInfoResponse::SharedCtor() { + _cached_size_ = 0; + game_time_remaining_info_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GetGameTimeRemainingInfoResponse::~GetGameTimeRemainingInfoResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse) + SharedDtor(); +} + +void GetGameTimeRemainingInfoResponse::SharedDtor() { + if (this != default_instance_) { + delete game_time_remaining_info_; + } +} + +void GetGameTimeRemainingInfoResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GetGameTimeRemainingInfoResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GetGameTimeRemainingInfoResponse_descriptor_; +} + +const GetGameTimeRemainingInfoResponse& GetGameTimeRemainingInfoResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +GetGameTimeRemainingInfoResponse* GetGameTimeRemainingInfoResponse::default_instance_ = NULL; + +GetGameTimeRemainingInfoResponse* GetGameTimeRemainingInfoResponse::New() const { + return new GetGameTimeRemainingInfoResponse; +} + +void GetGameTimeRemainingInfoResponse::Clear() { + if (has_game_time_remaining_info()) { + if (game_time_remaining_info_ != NULL) game_time_remaining_info_->::bgs::protocol::account::v1::GameTimeRemainingInfo::Clear(); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GetGameTimeRemainingInfoResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse) + 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 .bgs.protocol.account.v1.GameTimeRemainingInfo game_time_remaining_info = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_time_remaining_info())); + } 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:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse) + return false; +#undef DO_ +} + +void GetGameTimeRemainingInfoResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse) + // optional .bgs.protocol.account.v1.GameTimeRemainingInfo game_time_remaining_info = 1; + if (has_game_time_remaining_info()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->game_time_remaining_info(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse) +} + +::google::protobuf::uint8* GetGameTimeRemainingInfoResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse) + // optional .bgs.protocol.account.v1.GameTimeRemainingInfo game_time_remaining_info = 1; + if (has_game_time_remaining_info()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->game_time_remaining_info(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse) + return target; +} + +int GetGameTimeRemainingInfoResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.account.v1.GameTimeRemainingInfo game_time_remaining_info = 1; + if (has_game_time_remaining_info()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_time_remaining_info()); + } + + } + 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 GetGameTimeRemainingInfoResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GetGameTimeRemainingInfoResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GetGameTimeRemainingInfoResponse::MergeFrom(const GetGameTimeRemainingInfoResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_game_time_remaining_info()) { + mutable_game_time_remaining_info()->::bgs::protocol::account::v1::GameTimeRemainingInfo::MergeFrom(from.game_time_remaining_info()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GetGameTimeRemainingInfoResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetGameTimeRemainingInfoResponse::CopyFrom(const GetGameTimeRemainingInfoResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetGameTimeRemainingInfoResponse::IsInitialized() const { + + return true; +} + +void GetGameTimeRemainingInfoResponse::Swap(GetGameTimeRemainingInfoResponse* other) { + if (other != this) { + std::swap(game_time_remaining_info_, other->game_time_remaining_info_); + 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 GetGameTimeRemainingInfoResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GetGameTimeRemainingInfoResponse_descriptor_; + metadata.reflection = GetGameTimeRemainingInfoResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GetCAISInfoRequest::kEntityIdFieldNumber; +#endif // !_MSC_VER + +GetCAISInfoRequest::GetCAISInfoRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetCAISInfoRequest) +} + +void GetCAISInfoRequest::InitAsDefaultInstance() { + entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +GetCAISInfoRequest::GetCAISInfoRequest(const GetCAISInfoRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetCAISInfoRequest) +} + +void GetCAISInfoRequest::SharedCtor() { + _cached_size_ = 0; + entity_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GetCAISInfoRequest::~GetCAISInfoRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetCAISInfoRequest) + SharedDtor(); +} + +void GetCAISInfoRequest::SharedDtor() { + if (this != default_instance_) { + delete entity_id_; + } +} + +void GetCAISInfoRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GetCAISInfoRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GetCAISInfoRequest_descriptor_; +} + +const GetCAISInfoRequest& GetCAISInfoRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +GetCAISInfoRequest* GetCAISInfoRequest::default_instance_ = NULL; + +GetCAISInfoRequest* GetCAISInfoRequest::New() const { + return new GetCAISInfoRequest; +} + +void GetCAISInfoRequest::Clear() { + if (has_entity_id()) { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GetCAISInfoRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetCAISInfoRequest) + 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 .bgs.protocol.EntityId entity_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_entity_id())); + } 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:bgs.protocol.account.v1.GetCAISInfoRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetCAISInfoRequest) + return false; +#undef DO_ +} + +void GetCAISInfoRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetCAISInfoRequest) + // optional .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->entity_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetCAISInfoRequest) +} + +::google::protobuf::uint8* GetCAISInfoRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetCAISInfoRequest) + // optional .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->entity_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetCAISInfoRequest) + return target; +} + +int GetCAISInfoRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->entity_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void GetCAISInfoRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GetCAISInfoRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GetCAISInfoRequest::MergeFrom(const GetCAISInfoRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_entity_id()) { + mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GetCAISInfoRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetCAISInfoRequest::CopyFrom(const GetCAISInfoRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetCAISInfoRequest::IsInitialized() const { + + if (has_entity_id()) { + if (!this->entity_id().IsInitialized()) return false; + } + return true; +} + +void GetCAISInfoRequest::Swap(GetCAISInfoRequest* other) { + if (other != this) { + std::swap(entity_id_, other->entity_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata GetCAISInfoRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GetCAISInfoRequest_descriptor_; + metadata.reflection = GetCAISInfoRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GetCAISInfoResponse::kCaisInfoFieldNumber; +#endif // !_MSC_VER + +GetCAISInfoResponse::GetCAISInfoResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetCAISInfoResponse) +} + +void GetCAISInfoResponse::InitAsDefaultInstance() { + cais_info_ = const_cast< ::bgs::protocol::account::v1::CAIS*>(&::bgs::protocol::account::v1::CAIS::default_instance()); +} + +GetCAISInfoResponse::GetCAISInfoResponse(const GetCAISInfoResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetCAISInfoResponse) +} + +void GetCAISInfoResponse::SharedCtor() { + _cached_size_ = 0; + cais_info_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GetCAISInfoResponse::~GetCAISInfoResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetCAISInfoResponse) + SharedDtor(); +} + +void GetCAISInfoResponse::SharedDtor() { + if (this != default_instance_) { + delete cais_info_; + } +} + +void GetCAISInfoResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GetCAISInfoResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GetCAISInfoResponse_descriptor_; +} + +const GetCAISInfoResponse& GetCAISInfoResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +GetCAISInfoResponse* GetCAISInfoResponse::default_instance_ = NULL; + +GetCAISInfoResponse* GetCAISInfoResponse::New() const { + return new GetCAISInfoResponse; +} + +void GetCAISInfoResponse::Clear() { + if (has_cais_info()) { + if (cais_info_ != NULL) cais_info_->::bgs::protocol::account::v1::CAIS::Clear(); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GetCAISInfoResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetCAISInfoResponse) + 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 .bgs.protocol.account.v1.CAIS cais_info = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_cais_info())); + } 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:bgs.protocol.account.v1.GetCAISInfoResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetCAISInfoResponse) + return false; +#undef DO_ +} + +void GetCAISInfoResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetCAISInfoResponse) + // optional .bgs.protocol.account.v1.CAIS cais_info = 1; + if (has_cais_info()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->cais_info(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetCAISInfoResponse) +} + +::google::protobuf::uint8* GetCAISInfoResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetCAISInfoResponse) + // optional .bgs.protocol.account.v1.CAIS cais_info = 1; + if (has_cais_info()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->cais_info(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetCAISInfoResponse) + return target; +} + +int GetCAISInfoResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.account.v1.CAIS cais_info = 1; + if (has_cais_info()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->cais_info()); + } + + } + 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 GetCAISInfoResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GetCAISInfoResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GetCAISInfoResponse::MergeFrom(const GetCAISInfoResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_cais_info()) { + mutable_cais_info()->::bgs::protocol::account::v1::CAIS::MergeFrom(from.cais_info()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GetCAISInfoResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetCAISInfoResponse::CopyFrom(const GetCAISInfoResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetCAISInfoResponse::IsInitialized() const { + + return true; +} + +void GetCAISInfoResponse::Swap(GetCAISInfoResponse* other) { + if (other != this) { + std::swap(cais_info_, other->cais_info_); + 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 GetCAISInfoResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GetCAISInfoResponse_descriptor_; + metadata.reflection = GetCAISInfoResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ForwardCacheExpireRequest::kEntityIdFieldNumber; +#endif // !_MSC_VER + +ForwardCacheExpireRequest::ForwardCacheExpireRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.ForwardCacheExpireRequest) +} + +void ForwardCacheExpireRequest::InitAsDefaultInstance() { + entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +ForwardCacheExpireRequest::ForwardCacheExpireRequest(const ForwardCacheExpireRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.ForwardCacheExpireRequest) +} + +void ForwardCacheExpireRequest::SharedCtor() { + _cached_size_ = 0; + entity_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ForwardCacheExpireRequest::~ForwardCacheExpireRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.ForwardCacheExpireRequest) + SharedDtor(); +} + +void ForwardCacheExpireRequest::SharedDtor() { + if (this != default_instance_) { + delete entity_id_; + } +} + +void ForwardCacheExpireRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ForwardCacheExpireRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ForwardCacheExpireRequest_descriptor_; +} + +const ForwardCacheExpireRequest& ForwardCacheExpireRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +ForwardCacheExpireRequest* ForwardCacheExpireRequest::default_instance_ = NULL; + +ForwardCacheExpireRequest* ForwardCacheExpireRequest::New() const { + return new ForwardCacheExpireRequest; +} + +void ForwardCacheExpireRequest::Clear() { + if (has_entity_id()) { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ForwardCacheExpireRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.ForwardCacheExpireRequest) + 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 .bgs.protocol.EntityId entity_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_entity_id())); + } 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:bgs.protocol.account.v1.ForwardCacheExpireRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.ForwardCacheExpireRequest) + return false; +#undef DO_ +} + +void ForwardCacheExpireRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.ForwardCacheExpireRequest) + // optional .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->entity_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.ForwardCacheExpireRequest) +} + +::google::protobuf::uint8* ForwardCacheExpireRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.ForwardCacheExpireRequest) + // optional .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->entity_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.ForwardCacheExpireRequest) + return target; +} + +int ForwardCacheExpireRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->entity_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ForwardCacheExpireRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ForwardCacheExpireRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ForwardCacheExpireRequest::MergeFrom(const ForwardCacheExpireRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_entity_id()) { + mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ForwardCacheExpireRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ForwardCacheExpireRequest::CopyFrom(const ForwardCacheExpireRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ForwardCacheExpireRequest::IsInitialized() const { + + if (has_entity_id()) { + if (!this->entity_id().IsInitialized()) return false; + } + return true; +} + +void ForwardCacheExpireRequest::Swap(ForwardCacheExpireRequest* other) { + if (other != this) { + std::swap(entity_id_, other->entity_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata ForwardCacheExpireRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ForwardCacheExpireRequest_descriptor_; + metadata.reflection = ForwardCacheExpireRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GetAuthorizedDataRequest::kEntityIdFieldNumber; +const int GetAuthorizedDataRequest::kTagFieldNumber; +const int GetAuthorizedDataRequest::kPrivilegedNetworkFieldNumber; +#endif // !_MSC_VER + +GetAuthorizedDataRequest::GetAuthorizedDataRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetAuthorizedDataRequest) +} + +void GetAuthorizedDataRequest::InitAsDefaultInstance() { + entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +GetAuthorizedDataRequest::GetAuthorizedDataRequest(const GetAuthorizedDataRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetAuthorizedDataRequest) +} + +void GetAuthorizedDataRequest::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + entity_id_ = NULL; + privileged_network_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GetAuthorizedDataRequest::~GetAuthorizedDataRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetAuthorizedDataRequest) + SharedDtor(); +} + +void GetAuthorizedDataRequest::SharedDtor() { + if (this != default_instance_) { + delete entity_id_; + } +} + +void GetAuthorizedDataRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GetAuthorizedDataRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GetAuthorizedDataRequest_descriptor_; +} + +const GetAuthorizedDataRequest& GetAuthorizedDataRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +GetAuthorizedDataRequest* GetAuthorizedDataRequest::default_instance_ = NULL; + +GetAuthorizedDataRequest* GetAuthorizedDataRequest::New() const { + return new GetAuthorizedDataRequest; +} + +void GetAuthorizedDataRequest::Clear() { + if (_has_bits_[0 / 32] & 5) { + if (has_entity_id()) { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + } + privileged_network_ = false; + } + tag_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GetAuthorizedDataRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetAuthorizedDataRequest) + 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 .bgs.protocol.EntityId entity_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_entity_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_tag; + break; + } + + // repeated string tag = 2; + case 2: { + if (tag == 18) { + parse_tag: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_tag())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->tag(this->tag_size() - 1).data(), + this->tag(this->tag_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE, + "tag"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_tag; + if (input->ExpectTag(24)) goto parse_privileged_network; + break; + } + + // optional bool privileged_network = 3; + case 3: { + if (tag == 24) { + parse_privileged_network: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &privileged_network_))); + set_has_privileged_network(); + } 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:bgs.protocol.account.v1.GetAuthorizedDataRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetAuthorizedDataRequest) + return false; +#undef DO_ +} + +void GetAuthorizedDataRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetAuthorizedDataRequest) + // optional .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->entity_id(), output); + } + + // repeated string tag = 2; + for (int i = 0; i < this->tag_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->tag(i).data(), this->tag(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "tag"); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->tag(i), output); + } + + // optional bool privileged_network = 3; + if (has_privileged_network()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->privileged_network(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetAuthorizedDataRequest) +} + +::google::protobuf::uint8* GetAuthorizedDataRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetAuthorizedDataRequest) + // optional .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->entity_id(), target); + } + + // repeated string tag = 2; + for (int i = 0; i < this->tag_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->tag(i).data(), this->tag(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "tag"); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(2, this->tag(i), target); + } + + // optional bool privileged_network = 3; + if (has_privileged_network()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->privileged_network(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetAuthorizedDataRequest) + return target; +} + +int GetAuthorizedDataRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->entity_id()); + } + + // optional bool privileged_network = 3; + if (has_privileged_network()) { + total_size += 1 + 1; + } + + } + // repeated string tag = 2; + total_size += 1 * this->tag_size(); + for (int i = 0; i < this->tag_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->tag(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 GetAuthorizedDataRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GetAuthorizedDataRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GetAuthorizedDataRequest::MergeFrom(const GetAuthorizedDataRequest& from) { + GOOGLE_CHECK_NE(&from, this); + tag_.MergeFrom(from.tag_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_entity_id()) { + mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id()); + } + if (from.has_privileged_network()) { + set_privileged_network(from.privileged_network()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GetAuthorizedDataRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetAuthorizedDataRequest::CopyFrom(const GetAuthorizedDataRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetAuthorizedDataRequest::IsInitialized() const { + + if (has_entity_id()) { + if (!this->entity_id().IsInitialized()) return false; + } + return true; +} + +void GetAuthorizedDataRequest::Swap(GetAuthorizedDataRequest* other) { + if (other != this) { + std::swap(entity_id_, other->entity_id_); + tag_.Swap(&other->tag_); + std::swap(privileged_network_, other->privileged_network_); + 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 GetAuthorizedDataRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GetAuthorizedDataRequest_descriptor_; + metadata.reflection = GetAuthorizedDataRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GetAuthorizedDataResponse::kDataFieldNumber; +#endif // !_MSC_VER + +GetAuthorizedDataResponse::GetAuthorizedDataResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetAuthorizedDataResponse) +} + +void GetAuthorizedDataResponse::InitAsDefaultInstance() { +} + +GetAuthorizedDataResponse::GetAuthorizedDataResponse(const GetAuthorizedDataResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetAuthorizedDataResponse) +} + +void GetAuthorizedDataResponse::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GetAuthorizedDataResponse::~GetAuthorizedDataResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetAuthorizedDataResponse) + SharedDtor(); +} + +void GetAuthorizedDataResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void GetAuthorizedDataResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GetAuthorizedDataResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GetAuthorizedDataResponse_descriptor_; +} + +const GetAuthorizedDataResponse& GetAuthorizedDataResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +GetAuthorizedDataResponse* GetAuthorizedDataResponse::default_instance_ = NULL; + +GetAuthorizedDataResponse* GetAuthorizedDataResponse::New() const { + return new GetAuthorizedDataResponse; +} + +void GetAuthorizedDataResponse::Clear() { + data_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GetAuthorizedDataResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetAuthorizedDataResponse) + 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 .bgs.protocol.account.v1.AuthorizedData data = 1; + case 1: { + if (tag == 10) { + parse_data: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_data())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_data; + 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:bgs.protocol.account.v1.GetAuthorizedDataResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetAuthorizedDataResponse) + return false; +#undef DO_ +} + +void GetAuthorizedDataResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetAuthorizedDataResponse) + // repeated .bgs.protocol.account.v1.AuthorizedData data = 1; + for (int i = 0; i < this->data_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->data(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetAuthorizedDataResponse) +} + +::google::protobuf::uint8* GetAuthorizedDataResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetAuthorizedDataResponse) + // repeated .bgs.protocol.account.v1.AuthorizedData data = 1; + for (int i = 0; i < this->data_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->data(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetAuthorizedDataResponse) + return target; +} + +int GetAuthorizedDataResponse::ByteSize() const { + int total_size = 0; + + // repeated .bgs.protocol.account.v1.AuthorizedData data = 1; + total_size += 1 * this->data_size(); + for (int i = 0; i < this->data_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->data(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 GetAuthorizedDataResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GetAuthorizedDataResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GetAuthorizedDataResponse::MergeFrom(const GetAuthorizedDataResponse& from) { + GOOGLE_CHECK_NE(&from, this); + data_.MergeFrom(from.data_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GetAuthorizedDataResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetAuthorizedDataResponse::CopyFrom(const GetAuthorizedDataResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetAuthorizedDataResponse::IsInitialized() const { + + return true; +} + +void GetAuthorizedDataResponse::Swap(GetAuthorizedDataResponse* other) { + if (other != this) { + data_.Swap(&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 GetAuthorizedDataResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GetAuthorizedDataResponse_descriptor_; + metadata.reflection = GetAuthorizedDataResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AccountStateNotification::kAccountStateFieldNumber; +const int AccountStateNotification::kSubscriberIdFieldNumber; +const int AccountStateNotification::kAccountTagsFieldNumber; +const int AccountStateNotification::kSubscriptionCompletedFieldNumber; +#endif // !_MSC_VER + +AccountStateNotification::AccountStateNotification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountStateNotification) +} + +void AccountStateNotification::InitAsDefaultInstance() { + account_state_ = const_cast< ::bgs::protocol::account::v1::AccountState*>(&::bgs::protocol::account::v1::AccountState::default_instance()); + account_tags_ = const_cast< ::bgs::protocol::account::v1::AccountFieldTags*>(&::bgs::protocol::account::v1::AccountFieldTags::default_instance()); +} + +AccountStateNotification::AccountStateNotification(const AccountStateNotification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountStateNotification) +} + +void AccountStateNotification::SharedCtor() { + _cached_size_ = 0; + account_state_ = NULL; + subscriber_id_ = GOOGLE_ULONGLONG(0); + account_tags_ = NULL; + subscription_completed_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AccountStateNotification::~AccountStateNotification() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountStateNotification) + SharedDtor(); +} + +void AccountStateNotification::SharedDtor() { + if (this != default_instance_) { + delete account_state_; + delete account_tags_; + } +} + +void AccountStateNotification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AccountStateNotification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AccountStateNotification_descriptor_; +} + +const AccountStateNotification& AccountStateNotification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +AccountStateNotification* AccountStateNotification::default_instance_ = NULL; + +AccountStateNotification* AccountStateNotification::New() const { + return new AccountStateNotification; +} + +void AccountStateNotification::Clear() { + if (_has_bits_[0 / 32] & 15) { + if (has_account_state()) { + if (account_state_ != NULL) account_state_->::bgs::protocol::account::v1::AccountState::Clear(); + } + subscriber_id_ = GOOGLE_ULONGLONG(0); + if (has_account_tags()) { + if (account_tags_ != NULL) account_tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear(); + } + subscription_completed_ = false; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AccountStateNotification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountStateNotification) + 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 .bgs.protocol.account.v1.AccountState account_state = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account_state())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_subscriber_id; + break; + } + + // optional uint64 subscriber_id = 2; + case 2: { + if (tag == 16) { + parse_subscriber_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &subscriber_id_))); + set_has_subscriber_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_account_tags; + break; + } + + // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3; + case 3: { + if (tag == 26) { + parse_account_tags: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account_tags())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_subscription_completed; + break; + } + + // optional bool subscription_completed = 4; + case 4: { + if (tag == 32) { + parse_subscription_completed: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &subscription_completed_))); + set_has_subscription_completed(); + } 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:bgs.protocol.account.v1.AccountStateNotification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountStateNotification) + return false; +#undef DO_ +} + +void AccountStateNotification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountStateNotification) + // optional .bgs.protocol.account.v1.AccountState account_state = 1; + if (has_account_state()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->account_state(), output); + } + + // optional uint64 subscriber_id = 2; + if (has_subscriber_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->subscriber_id(), output); + } + + // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3; + if (has_account_tags()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->account_tags(), output); + } + + // optional bool subscription_completed = 4; + if (has_subscription_completed()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->subscription_completed(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountStateNotification) +} + +::google::protobuf::uint8* AccountStateNotification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountStateNotification) + // optional .bgs.protocol.account.v1.AccountState account_state = 1; + if (has_account_state()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->account_state(), target); + } + + // optional uint64 subscriber_id = 2; + if (has_subscriber_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->subscriber_id(), target); + } + + // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3; + if (has_account_tags()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->account_tags(), target); + } + + // optional bool subscription_completed = 4; + if (has_subscription_completed()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->subscription_completed(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountStateNotification) + return target; +} + +int AccountStateNotification::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.account.v1.AccountState account_state = 1; + if (has_account_state()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account_state()); + } + + // optional uint64 subscriber_id = 2; + if (has_subscriber_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->subscriber_id()); + } + + // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3; + if (has_account_tags()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account_tags()); + } + + // optional bool subscription_completed = 4; + if (has_subscription_completed()) { + 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 AccountStateNotification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AccountStateNotification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AccountStateNotification::MergeFrom(const AccountStateNotification& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_account_state()) { + mutable_account_state()->::bgs::protocol::account::v1::AccountState::MergeFrom(from.account_state()); + } + if (from.has_subscriber_id()) { + set_subscriber_id(from.subscriber_id()); + } + if (from.has_account_tags()) { + mutable_account_tags()->::bgs::protocol::account::v1::AccountFieldTags::MergeFrom(from.account_tags()); + } + if (from.has_subscription_completed()) { + set_subscription_completed(from.subscription_completed()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AccountStateNotification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AccountStateNotification::CopyFrom(const AccountStateNotification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AccountStateNotification::IsInitialized() const { + + if (has_account_state()) { + if (!this->account_state().IsInitialized()) return false; + } + return true; +} + +void AccountStateNotification::Swap(AccountStateNotification* other) { + if (other != this) { + std::swap(account_state_, other->account_state_); + std::swap(subscriber_id_, other->subscriber_id_); + std::swap(account_tags_, other->account_tags_); + std::swap(subscription_completed_, other->subscription_completed_); + 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 AccountStateNotification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AccountStateNotification_descriptor_; + metadata.reflection = AccountStateNotification_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GameAccountStateNotification::kGameAccountStateFieldNumber; +const int GameAccountStateNotification::kSubscriberIdFieldNumber; +const int GameAccountStateNotification::kGameAccountTagsFieldNumber; +const int GameAccountStateNotification::kSubscriptionCompletedFieldNumber; +#endif // !_MSC_VER + +GameAccountStateNotification::GameAccountStateNotification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountStateNotification) +} + +void GameAccountStateNotification::InitAsDefaultInstance() { + game_account_state_ = const_cast< ::bgs::protocol::account::v1::GameAccountState*>(&::bgs::protocol::account::v1::GameAccountState::default_instance()); + game_account_tags_ = const_cast< ::bgs::protocol::account::v1::GameAccountFieldTags*>(&::bgs::protocol::account::v1::GameAccountFieldTags::default_instance()); +} + +GameAccountStateNotification::GameAccountStateNotification(const GameAccountStateNotification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountStateNotification) +} + +void GameAccountStateNotification::SharedCtor() { + _cached_size_ = 0; + game_account_state_ = NULL; + subscriber_id_ = GOOGLE_ULONGLONG(0); + game_account_tags_ = NULL; + subscription_completed_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameAccountStateNotification::~GameAccountStateNotification() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountStateNotification) + SharedDtor(); +} + +void GameAccountStateNotification::SharedDtor() { + if (this != default_instance_) { + delete game_account_state_; + delete game_account_tags_; + } +} + +void GameAccountStateNotification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GameAccountStateNotification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GameAccountStateNotification_descriptor_; +} + +const GameAccountStateNotification& GameAccountStateNotification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +GameAccountStateNotification* GameAccountStateNotification::default_instance_ = NULL; + +GameAccountStateNotification* GameAccountStateNotification::New() const { + return new GameAccountStateNotification; +} + +void GameAccountStateNotification::Clear() { + if (_has_bits_[0 / 32] & 15) { + if (has_game_account_state()) { + if (game_account_state_ != NULL) game_account_state_->::bgs::protocol::account::v1::GameAccountState::Clear(); + } + subscriber_id_ = GOOGLE_ULONGLONG(0); + if (has_game_account_tags()) { + if (game_account_tags_ != NULL) game_account_tags_->::bgs::protocol::account::v1::GameAccountFieldTags::Clear(); + } + subscription_completed_ = false; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GameAccountStateNotification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountStateNotification) + 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 .bgs.protocol.account.v1.GameAccountState game_account_state = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account_state())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_subscriber_id; + break; + } + + // optional uint64 subscriber_id = 2; + case 2: { + if (tag == 16) { + parse_subscriber_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &subscriber_id_))); + set_has_subscriber_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_game_account_tags; + break; + } + + // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 3; + case 3: { + if (tag == 26) { + parse_game_account_tags: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account_tags())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_subscription_completed; + break; + } + + // optional bool subscription_completed = 4; + case 4: { + if (tag == 32) { + parse_subscription_completed: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &subscription_completed_))); + set_has_subscription_completed(); + } 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:bgs.protocol.account.v1.GameAccountStateNotification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountStateNotification) + return false; +#undef DO_ +} + +void GameAccountStateNotification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountStateNotification) + // optional .bgs.protocol.account.v1.GameAccountState game_account_state = 1; + if (has_game_account_state()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->game_account_state(), output); + } + + // optional uint64 subscriber_id = 2; + if (has_subscriber_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->subscriber_id(), output); + } + + // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 3; + if (has_game_account_tags()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->game_account_tags(), output); + } + + // optional bool subscription_completed = 4; + if (has_subscription_completed()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->subscription_completed(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountStateNotification) +} + +::google::protobuf::uint8* GameAccountStateNotification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountStateNotification) + // optional .bgs.protocol.account.v1.GameAccountState game_account_state = 1; + if (has_game_account_state()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->game_account_state(), target); + } + + // optional uint64 subscriber_id = 2; + if (has_subscriber_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->subscriber_id(), target); + } + + // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 3; + if (has_game_account_tags()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->game_account_tags(), target); + } + + // optional bool subscription_completed = 4; + if (has_subscription_completed()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->subscription_completed(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountStateNotification) + return target; +} + +int GameAccountStateNotification::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.account.v1.GameAccountState game_account_state = 1; + if (has_game_account_state()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account_state()); + } + + // optional uint64 subscriber_id = 2; + if (has_subscriber_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->subscriber_id()); + } + + // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 3; + if (has_game_account_tags()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account_tags()); + } + + // optional bool subscription_completed = 4; + if (has_subscription_completed()) { + 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 GameAccountStateNotification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GameAccountStateNotification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GameAccountStateNotification::MergeFrom(const GameAccountStateNotification& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_game_account_state()) { + mutable_game_account_state()->::bgs::protocol::account::v1::GameAccountState::MergeFrom(from.game_account_state()); + } + if (from.has_subscriber_id()) { + set_subscriber_id(from.subscriber_id()); + } + if (from.has_game_account_tags()) { + mutable_game_account_tags()->::bgs::protocol::account::v1::GameAccountFieldTags::MergeFrom(from.game_account_tags()); + } + if (from.has_subscription_completed()) { + set_subscription_completed(from.subscription_completed()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GameAccountStateNotification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GameAccountStateNotification::CopyFrom(const GameAccountStateNotification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameAccountStateNotification::IsInitialized() const { + + if (has_game_account_state()) { + if (!this->game_account_state().IsInitialized()) return false; + } + return true; +} + +void GameAccountStateNotification::Swap(GameAccountStateNotification* other) { + if (other != this) { + std::swap(game_account_state_, other->game_account_state_); + std::swap(subscriber_id_, other->subscriber_id_); + std::swap(game_account_tags_, other->game_account_tags_); + std::swap(subscription_completed_, other->subscription_completed_); + 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 GameAccountStateNotification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GameAccountStateNotification_descriptor_; + metadata.reflection = GameAccountStateNotification_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GameAccountNotification::kGameAccountsFieldNumber; +const int GameAccountNotification::kSubscriberIdFieldNumber; +const int GameAccountNotification::kAccountTagsFieldNumber; +#endif // !_MSC_VER + +GameAccountNotification::GameAccountNotification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountNotification) +} + +void GameAccountNotification::InitAsDefaultInstance() { + account_tags_ = const_cast< ::bgs::protocol::account::v1::AccountFieldTags*>(&::bgs::protocol::account::v1::AccountFieldTags::default_instance()); +} + +GameAccountNotification::GameAccountNotification(const GameAccountNotification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountNotification) +} + +void GameAccountNotification::SharedCtor() { + _cached_size_ = 0; + subscriber_id_ = GOOGLE_ULONGLONG(0); + account_tags_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameAccountNotification::~GameAccountNotification() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountNotification) + SharedDtor(); +} + +void GameAccountNotification::SharedDtor() { + if (this != default_instance_) { + delete account_tags_; + } +} + +void GameAccountNotification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GameAccountNotification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GameAccountNotification_descriptor_; +} + +const GameAccountNotification& GameAccountNotification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +GameAccountNotification* GameAccountNotification::default_instance_ = NULL; + +GameAccountNotification* GameAccountNotification::New() const { + return new GameAccountNotification; +} + +void GameAccountNotification::Clear() { + if (_has_bits_[0 / 32] & 6) { + subscriber_id_ = GOOGLE_ULONGLONG(0); + if (has_account_tags()) { + if (account_tags_ != NULL) account_tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear(); + } + } + game_accounts_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GameAccountNotification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountNotification) + 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 .bgs.protocol.account.v1.GameAccountList game_accounts = 1; + case 1: { + if (tag == 10) { + parse_game_accounts: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_game_accounts())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_game_accounts; + if (input->ExpectTag(16)) goto parse_subscriber_id; + break; + } + + // optional uint64 subscriber_id = 2; + case 2: { + if (tag == 16) { + parse_subscriber_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &subscriber_id_))); + set_has_subscriber_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_account_tags; + break; + } + + // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3; + case 3: { + if (tag == 26) { + parse_account_tags: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account_tags())); + } 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:bgs.protocol.account.v1.GameAccountNotification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountNotification) + return false; +#undef DO_ +} + +void GameAccountNotification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountNotification) + // repeated .bgs.protocol.account.v1.GameAccountList game_accounts = 1; + for (int i = 0; i < this->game_accounts_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->game_accounts(i), output); + } + + // optional uint64 subscriber_id = 2; + if (has_subscriber_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->subscriber_id(), output); + } + + // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3; + if (has_account_tags()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->account_tags(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountNotification) +} + +::google::protobuf::uint8* GameAccountNotification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountNotification) + // repeated .bgs.protocol.account.v1.GameAccountList game_accounts = 1; + for (int i = 0; i < this->game_accounts_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->game_accounts(i), target); + } + + // optional uint64 subscriber_id = 2; + if (has_subscriber_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->subscriber_id(), target); + } + + // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3; + if (has_account_tags()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->account_tags(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountNotification) + return target; +} + +int GameAccountNotification::ByteSize() const { + int total_size = 0; + + if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) { + // optional uint64 subscriber_id = 2; + if (has_subscriber_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->subscriber_id()); + } + + // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3; + if (has_account_tags()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account_tags()); + } + + } + // repeated .bgs.protocol.account.v1.GameAccountList game_accounts = 1; + total_size += 1 * this->game_accounts_size(); + for (int i = 0; i < this->game_accounts_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_accounts(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 GameAccountNotification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GameAccountNotification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GameAccountNotification::MergeFrom(const GameAccountNotification& from) { + GOOGLE_CHECK_NE(&from, this); + game_accounts_.MergeFrom(from.game_accounts_); + if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) { + if (from.has_subscriber_id()) { + set_subscriber_id(from.subscriber_id()); + } + if (from.has_account_tags()) { + mutable_account_tags()->::bgs::protocol::account::v1::AccountFieldTags::MergeFrom(from.account_tags()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GameAccountNotification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GameAccountNotification::CopyFrom(const GameAccountNotification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameAccountNotification::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->game_accounts())) return false; + return true; +} + +void GameAccountNotification::Swap(GameAccountNotification* other) { + if (other != this) { + game_accounts_.Swap(&other->game_accounts_); + std::swap(subscriber_id_, other->subscriber_id_); + std::swap(account_tags_, other->account_tags_); + 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 GameAccountNotification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GameAccountNotification_descriptor_; + metadata.reflection = GameAccountNotification_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GameAccountSessionNotification::kGameAccountFieldNumber; +const int GameAccountSessionNotification::kSessionInfoFieldNumber; +#endif // !_MSC_VER + +GameAccountSessionNotification::GameAccountSessionNotification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountSessionNotification) +} + +void GameAccountSessionNotification::InitAsDefaultInstance() { + game_account_ = const_cast< ::bgs::protocol::account::v1::GameAccountHandle*>(&::bgs::protocol::account::v1::GameAccountHandle::default_instance()); + session_info_ = const_cast< ::bgs::protocol::account::v1::GameSessionUpdateInfo*>(&::bgs::protocol::account::v1::GameSessionUpdateInfo::default_instance()); +} + +GameAccountSessionNotification::GameAccountSessionNotification(const GameAccountSessionNotification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountSessionNotification) +} + +void GameAccountSessionNotification::SharedCtor() { + _cached_size_ = 0; + game_account_ = NULL; + session_info_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameAccountSessionNotification::~GameAccountSessionNotification() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountSessionNotification) + SharedDtor(); +} + +void GameAccountSessionNotification::SharedDtor() { + if (this != default_instance_) { + delete game_account_; + delete session_info_; + } +} + +void GameAccountSessionNotification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GameAccountSessionNotification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GameAccountSessionNotification_descriptor_; +} + +const GameAccountSessionNotification& GameAccountSessionNotification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto(); + return *default_instance_; +} + +GameAccountSessionNotification* GameAccountSessionNotification::default_instance_ = NULL; + +GameAccountSessionNotification* GameAccountSessionNotification::New() const { + return new GameAccountSessionNotification; +} + +void GameAccountSessionNotification::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_game_account()) { + if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear(); + } + if (has_session_info()) { + if (session_info_ != NULL) session_info_->::bgs::protocol::account::v1::GameSessionUpdateInfo::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GameAccountSessionNotification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountSessionNotification) + 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 .bgs.protocol.account.v1.GameAccountHandle game_account = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_session_info; + break; + } + + // optional .bgs.protocol.account.v1.GameSessionUpdateInfo session_info = 2; + case 2: { + if (tag == 18) { + parse_session_info: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_session_info())); + } 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:bgs.protocol.account.v1.GameAccountSessionNotification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountSessionNotification) + return false; +#undef DO_ +} + +void GameAccountSessionNotification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountSessionNotification) + // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1; + if (has_game_account()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->game_account(), output); + } + + // optional .bgs.protocol.account.v1.GameSessionUpdateInfo session_info = 2; + if (has_session_info()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->session_info(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountSessionNotification) +} + +::google::protobuf::uint8* GameAccountSessionNotification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountSessionNotification) + // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1; + if (has_game_account()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->game_account(), target); + } + + // optional .bgs.protocol.account.v1.GameSessionUpdateInfo session_info = 2; + if (has_session_info()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->session_info(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountSessionNotification) + return target; +} + +int GameAccountSessionNotification::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1; + if (has_game_account()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account()); + } + + // optional .bgs.protocol.account.v1.GameSessionUpdateInfo session_info = 2; + if (has_session_info()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->session_info()); + } + + } + 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 GameAccountSessionNotification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GameAccountSessionNotification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GameAccountSessionNotification::MergeFrom(const GameAccountSessionNotification& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_game_account()) { + mutable_game_account()->::bgs::protocol::account::v1::GameAccountHandle::MergeFrom(from.game_account()); + } + if (from.has_session_info()) { + mutable_session_info()->::bgs::protocol::account::v1::GameSessionUpdateInfo::MergeFrom(from.session_info()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GameAccountSessionNotification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GameAccountSessionNotification::CopyFrom(const GameAccountSessionNotification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameAccountSessionNotification::IsInitialized() const { + + if (has_game_account()) { + if (!this->game_account().IsInitialized()) return false; + } + return true; +} + +void GameAccountSessionNotification::Swap(GameAccountSessionNotification* other) { + if (other != this) { + std::swap(game_account_, other->game_account_); + std::swap(session_info_, other->session_info_); + 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 GameAccountSessionNotification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GameAccountSessionNotification_descriptor_; + metadata.reflection = GameAccountSessionNotification_reflection_; + return metadata; +} + + +// =================================================================== + +google::protobuf::ServiceDescriptor const* AccountService::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AccountService_descriptor_; +} + +void AccountService::GetGameAccount(::bgs::protocol::account::v1::GameAccountHandle const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GetGameAccount(bgs.protocol.account.v1.GameAccountHandle{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 12, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::account::v1::GameAccountBlob response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AccountService::GetAccount(::bgs::protocol::account::v1::GetAccountRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GetAccount(bgs.protocol.account.v1.GetAccountRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 13, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::account::v1::GetAccountResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AccountService::CreateGameAccount(::bgs::protocol::account::v1::CreateGameAccountRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.CreateGameAccount(bgs.protocol.account.v1.CreateGameAccountRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 14, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::account::v1::GameAccountHandle response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AccountService::IsIgrAddress(::bgs::protocol::account::v1::IsIgrAddressRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.IsIgrAddress(bgs.protocol.account.v1.IsIgrAddressRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 15, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AccountService::CacheExpire(::bgs::protocol::account::v1::CacheExpireRequest const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.CacheExpire(bgs.protocol.account.v1.CacheExpireRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 20, request); +} + +void AccountService::CredentialUpdate(::bgs::protocol::account::v1::CredentialUpdateRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.CredentialUpdate(bgs.protocol.account.v1.CredentialUpdateRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 21, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::account::v1::CredentialUpdateResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AccountService::Subscribe(::bgs::protocol::account::v1::SubscriptionUpdateRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.Subscribe(bgs.protocol.account.v1.SubscriptionUpdateRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 25, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::account::v1::SubscriptionUpdateResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AccountService::Unsubscribe(::bgs::protocol::account::v1::SubscriptionUpdateRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.Unsubscribe(bgs.protocol.account.v1.SubscriptionUpdateRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 26, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AccountService::GetAccountState(::bgs::protocol::account::v1::GetAccountStateRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GetAccountState(bgs.protocol.account.v1.GetAccountStateRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 30, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::account::v1::GetAccountStateResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AccountService::GetGameAccountState(::bgs::protocol::account::v1::GetGameAccountStateRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GetGameAccountState(bgs.protocol.account.v1.GetGameAccountStateRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 31, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::account::v1::GetGameAccountStateResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AccountService::GetLicenses(::bgs::protocol::account::v1::GetLicensesRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GetLicenses(bgs.protocol.account.v1.GetLicensesRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 32, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::account::v1::GetLicensesResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AccountService::GetGameTimeRemainingInfo(::bgs::protocol::account::v1::GetGameTimeRemainingInfoRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GetGameTimeRemainingInfo(bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 33, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::account::v1::GetGameTimeRemainingInfoResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AccountService::GetGameSessionInfo(::bgs::protocol::account::v1::GetGameSessionInfoRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GetGameSessionInfo(bgs.protocol.account.v1.GetGameSessionInfoRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 34, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::account::v1::GetGameSessionInfoResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AccountService::GetCAISInfo(::bgs::protocol::account::v1::GetCAISInfoRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GetCAISInfo(bgs.protocol.account.v1.GetCAISInfoRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 35, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::account::v1::GetCAISInfoResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AccountService::ForwardCacheExpire(::bgs::protocol::account::v1::ForwardCacheExpireRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.ForwardCacheExpire(bgs.protocol.account.v1.ForwardCacheExpireRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 36, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AccountService::GetAuthorizedData(::bgs::protocol::account::v1::GetAuthorizedDataRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GetAuthorizedData(bgs.protocol.account.v1.GetAuthorizedDataRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 37, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::account::v1::GetAuthorizedDataResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AccountService::AccountFlagUpdate(::bgs::protocol::account::v1::AccountFlagUpdateRequest const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.AccountFlagUpdate(bgs.protocol.account.v1.AccountFlagUpdateRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 38, request); +} + +void AccountService::GameAccountFlagUpdate(::bgs::protocol::account::v1::GameAccountFlagUpdateRequest const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GameAccountFlagUpdate(bgs.protocol.account.v1.GameAccountFlagUpdateRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 39, request); +} + +void AccountService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) { + switch(methodId) { + case 12: { + ::bgs::protocol::account::v1::GameAccountHandle request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GetGameAccount server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 12, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::account::v1::GameAccountBlob response; + uint32 status = HandleGetGameAccount(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetGameAccount(bgs.protocol.account.v1.GameAccountHandle{ %s }) returned bgs.protocol.account.v1.GameAccountBlob{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 12, token, &response); + else + SendResponse(service_hash_, 12, token, status); + break; + } + case 13: { + ::bgs::protocol::account::v1::GetAccountRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GetAccount server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 13, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::account::v1::GetAccountResponse response; + uint32 status = HandleGetAccount(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetAccount(bgs.protocol.account.v1.GetAccountRequest{ %s }) returned bgs.protocol.account.v1.GetAccountResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 13, token, &response); + else + SendResponse(service_hash_, 13, token, status); + break; + } + case 14: { + ::bgs::protocol::account::v1::CreateGameAccountRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.CreateGameAccount server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 14, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::account::v1::GameAccountHandle response; + uint32 status = HandleCreateGameAccount(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.CreateGameAccount(bgs.protocol.account.v1.CreateGameAccountRequest{ %s }) returned bgs.protocol.account.v1.GameAccountHandle{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 14, token, &response); + else + SendResponse(service_hash_, 14, token, status); + break; + } + case 15: { + ::bgs::protocol::account::v1::IsIgrAddressRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.IsIgrAddress server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 15, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleIsIgrAddress(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.IsIgrAddress(bgs.protocol.account.v1.IsIgrAddressRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 15, token, &response); + else + SendResponse(service_hash_, 15, token, status); + break; + } + case 20: { + ::bgs::protocol::account::v1::CacheExpireRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.CacheExpire server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 20, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleCacheExpire(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.CacheExpire(bgs.protocol.account.v1.CacheExpireRequest{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 20, token, status); + break; + } + case 21: { + ::bgs::protocol::account::v1::CredentialUpdateRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.CredentialUpdate server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 21, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::account::v1::CredentialUpdateResponse response; + uint32 status = HandleCredentialUpdate(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.CredentialUpdate(bgs.protocol.account.v1.CredentialUpdateRequest{ %s }) returned bgs.protocol.account.v1.CredentialUpdateResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 21, token, &response); + else + SendResponse(service_hash_, 21, token, status); + break; + } + case 25: { + ::bgs::protocol::account::v1::SubscriptionUpdateRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.Subscribe server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 25, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::account::v1::SubscriptionUpdateResponse response; + uint32 status = HandleSubscribe(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.Subscribe(bgs.protocol.account.v1.SubscriptionUpdateRequest{ %s }) returned bgs.protocol.account.v1.SubscriptionUpdateResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 25, token, &response); + else + SendResponse(service_hash_, 25, token, status); + break; + } + case 26: { + ::bgs::protocol::account::v1::SubscriptionUpdateRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.Unsubscribe server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 26, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleUnsubscribe(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.Unsubscribe(bgs.protocol.account.v1.SubscriptionUpdateRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 26, token, &response); + else + SendResponse(service_hash_, 26, token, status); + break; + } + case 30: { + ::bgs::protocol::account::v1::GetAccountStateRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GetAccountState server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 30, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::account::v1::GetAccountStateResponse response; + uint32 status = HandleGetAccountState(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetAccountState(bgs.protocol.account.v1.GetAccountStateRequest{ %s }) returned bgs.protocol.account.v1.GetAccountStateResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 30, token, &response); + else + SendResponse(service_hash_, 30, token, status); + break; + } + case 31: { + ::bgs::protocol::account::v1::GetGameAccountStateRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GetGameAccountState server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 31, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::account::v1::GetGameAccountStateResponse response; + uint32 status = HandleGetGameAccountState(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetGameAccountState(bgs.protocol.account.v1.GetGameAccountStateRequest{ %s }) returned bgs.protocol.account.v1.GetGameAccountStateResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 31, token, &response); + else + SendResponse(service_hash_, 31, token, status); + break; + } + case 32: { + ::bgs::protocol::account::v1::GetLicensesRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GetLicenses server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 32, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::account::v1::GetLicensesResponse response; + uint32 status = HandleGetLicenses(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetLicenses(bgs.protocol.account.v1.GetLicensesRequest{ %s }) returned bgs.protocol.account.v1.GetLicensesResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 32, token, &response); + else + SendResponse(service_hash_, 32, token, status); + break; + } + case 33: { + ::bgs::protocol::account::v1::GetGameTimeRemainingInfoRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GetGameTimeRemainingInfo server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 33, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::account::v1::GetGameTimeRemainingInfoResponse response; + uint32 status = HandleGetGameTimeRemainingInfo(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetGameTimeRemainingInfo(bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest{ %s }) returned bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 33, token, &response); + else + SendResponse(service_hash_, 33, token, status); + break; + } + case 34: { + ::bgs::protocol::account::v1::GetGameSessionInfoRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GetGameSessionInfo server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 34, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::account::v1::GetGameSessionInfoResponse response; + uint32 status = HandleGetGameSessionInfo(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetGameSessionInfo(bgs.protocol.account.v1.GetGameSessionInfoRequest{ %s }) returned bgs.protocol.account.v1.GetGameSessionInfoResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 34, token, &response); + else + SendResponse(service_hash_, 34, token, status); + break; + } + case 35: { + ::bgs::protocol::account::v1::GetCAISInfoRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GetCAISInfo server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 35, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::account::v1::GetCAISInfoResponse response; + uint32 status = HandleGetCAISInfo(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetCAISInfo(bgs.protocol.account.v1.GetCAISInfoRequest{ %s }) returned bgs.protocol.account.v1.GetCAISInfoResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 35, token, &response); + else + SendResponse(service_hash_, 35, token, status); + break; + } + case 36: { + ::bgs::protocol::account::v1::ForwardCacheExpireRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.ForwardCacheExpire server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 36, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleForwardCacheExpire(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.ForwardCacheExpire(bgs.protocol.account.v1.ForwardCacheExpireRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 36, token, &response); + else + SendResponse(service_hash_, 36, token, status); + break; + } + case 37: { + ::bgs::protocol::account::v1::GetAuthorizedDataRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GetAuthorizedData server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 37, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::account::v1::GetAuthorizedDataResponse response; + uint32 status = HandleGetAuthorizedData(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetAuthorizedData(bgs.protocol.account.v1.GetAuthorizedDataRequest{ %s }) returned bgs.protocol.account.v1.GetAuthorizedDataResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 37, token, &response); + else + SendResponse(service_hash_, 37, token, status); + break; + } + case 38: { + ::bgs::protocol::account::v1::AccountFlagUpdateRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.AccountFlagUpdate server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 38, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleAccountFlagUpdate(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.AccountFlagUpdate(bgs.protocol.account.v1.AccountFlagUpdateRequest{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 38, token, status); + break; + } + case 39: { + ::bgs::protocol::account::v1::GameAccountFlagUpdateRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GameAccountFlagUpdate server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 39, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleGameAccountFlagUpdate(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GameAccountFlagUpdate(bgs.protocol.account.v1.GameAccountFlagUpdateRequest{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 39, token, status); + break; + } + default: + TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId); + SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD); + break; + } +} + +uint32 AccountService::HandleGetGameAccount(::bgs::protocol::account::v1::GameAccountHandle const* request, ::bgs::protocol::account::v1::GameAccountBlob* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GetGameAccount({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AccountService::HandleGetAccount(::bgs::protocol::account::v1::GetAccountRequest const* request, ::bgs::protocol::account::v1::GetAccountResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GetAccount({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AccountService::HandleCreateGameAccount(::bgs::protocol::account::v1::CreateGameAccountRequest const* request, ::bgs::protocol::account::v1::GameAccountHandle* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.CreateGameAccount({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AccountService::HandleIsIgrAddress(::bgs::protocol::account::v1::IsIgrAddressRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.IsIgrAddress({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AccountService::HandleCacheExpire(::bgs::protocol::account::v1::CacheExpireRequest const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.CacheExpire({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AccountService::HandleCredentialUpdate(::bgs::protocol::account::v1::CredentialUpdateRequest const* request, ::bgs::protocol::account::v1::CredentialUpdateResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.CredentialUpdate({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AccountService::HandleSubscribe(::bgs::protocol::account::v1::SubscriptionUpdateRequest const* request, ::bgs::protocol::account::v1::SubscriptionUpdateResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.Subscribe({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AccountService::HandleUnsubscribe(::bgs::protocol::account::v1::SubscriptionUpdateRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.Unsubscribe({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AccountService::HandleGetAccountState(::bgs::protocol::account::v1::GetAccountStateRequest const* request, ::bgs::protocol::account::v1::GetAccountStateResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GetAccountState({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AccountService::HandleGetGameAccountState(::bgs::protocol::account::v1::GetGameAccountStateRequest const* request, ::bgs::protocol::account::v1::GetGameAccountStateResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GetGameAccountState({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AccountService::HandleGetLicenses(::bgs::protocol::account::v1::GetLicensesRequest const* request, ::bgs::protocol::account::v1::GetLicensesResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GetLicenses({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AccountService::HandleGetGameTimeRemainingInfo(::bgs::protocol::account::v1::GetGameTimeRemainingInfoRequest const* request, ::bgs::protocol::account::v1::GetGameTimeRemainingInfoResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GetGameTimeRemainingInfo({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AccountService::HandleGetGameSessionInfo(::bgs::protocol::account::v1::GetGameSessionInfoRequest const* request, ::bgs::protocol::account::v1::GetGameSessionInfoResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GetGameSessionInfo({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AccountService::HandleGetCAISInfo(::bgs::protocol::account::v1::GetCAISInfoRequest const* request, ::bgs::protocol::account::v1::GetCAISInfoResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GetCAISInfo({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AccountService::HandleForwardCacheExpire(::bgs::protocol::account::v1::ForwardCacheExpireRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.ForwardCacheExpire({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AccountService::HandleGetAuthorizedData(::bgs::protocol::account::v1::GetAuthorizedDataRequest const* request, ::bgs::protocol::account::v1::GetAuthorizedDataResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GetAuthorizedData({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AccountService::HandleAccountFlagUpdate(::bgs::protocol::account::v1::AccountFlagUpdateRequest const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.AccountFlagUpdate({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AccountService::HandleGameAccountFlagUpdate(::bgs::protocol::account::v1::GameAccountFlagUpdateRequest const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GameAccountFlagUpdate({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +// =================================================================== + +google::protobuf::ServiceDescriptor const* AccountListener::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AccountListener_descriptor_; +} + +void AccountListener::OnAccountStateUpdated(::bgs::protocol::account::v1::AccountStateNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountListener.OnAccountStateUpdated(bgs.protocol.account.v1.AccountStateNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 1, request); +} + +void AccountListener::OnGameAccountStateUpdated(::bgs::protocol::account::v1::GameAccountStateNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountListener.OnGameAccountStateUpdated(bgs.protocol.account.v1.GameAccountStateNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 2, request); +} + +void AccountListener::OnGameAccountsUpdated(::bgs::protocol::account::v1::GameAccountNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountListener.OnGameAccountsUpdated(bgs.protocol.account.v1.GameAccountNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 3, request); +} + +void AccountListener::OnGameSessionUpdated(::bgs::protocol::account::v1::GameAccountSessionNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountListener.OnGameSessionUpdated(bgs.protocol.account.v1.GameAccountSessionNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 4, request); +} + +void AccountListener::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) { + switch(methodId) { + case 1: { + ::bgs::protocol::account::v1::AccountStateNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountListener.OnAccountStateUpdated server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnAccountStateUpdated(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountListener.OnAccountStateUpdated(bgs.protocol.account.v1.AccountStateNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 1, token, status); + break; + } + case 2: { + ::bgs::protocol::account::v1::GameAccountStateNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountListener.OnGameAccountStateUpdated server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnGameAccountStateUpdated(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountListener.OnGameAccountStateUpdated(bgs.protocol.account.v1.GameAccountStateNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 2, token, status); + break; + } + case 3: { + ::bgs::protocol::account::v1::GameAccountNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountListener.OnGameAccountsUpdated server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnGameAccountsUpdated(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountListener.OnGameAccountsUpdated(bgs.protocol.account.v1.GameAccountNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 3, token, status); + break; + } + case 4: { + ::bgs::protocol::account::v1::GameAccountSessionNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountListener.OnGameSessionUpdated server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnGameSessionUpdated(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountListener.OnGameSessionUpdated(bgs.protocol.account.v1.GameAccountSessionNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 4, token, status); + break; + } + default: + TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId); + SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD); + break; + } +} + +uint32 AccountListener::HandleOnAccountStateUpdated(::bgs::protocol::account::v1::AccountStateNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountListener.OnAccountStateUpdated({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AccountListener::HandleOnGameAccountStateUpdated(::bgs::protocol::account::v1::GameAccountStateNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountListener.OnGameAccountStateUpdated({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AccountListener::HandleOnGameAccountsUpdated(::bgs::protocol::account::v1::GameAccountNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountListener.OnGameAccountsUpdated({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AccountListener::HandleOnGameSessionUpdated(::bgs::protocol::account::v1::GameAccountSessionNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountListener.OnGameSessionUpdated({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace account +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/account_service.pb.h b/src/server/proto/Client/account_service.pb.h new file mode 100644 index 00000000000..fb65de7145b --- /dev/null +++ b/src/server/proto/Client/account_service.pb.h @@ -0,0 +1,6583 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: account_service.proto + +#ifndef PROTOBUF_account_5fservice_2eproto__INCLUDED +#define PROTOBUF_account_5fservice_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include "account_types.pb.h" +#include "entity_types.pb.h" +#include "rpc_types.pb.h" +#include "ServiceBase.h" +#include "MessageBuffer.h" +#include +#include +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { +namespace account { +namespace v1 { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); +void protobuf_AssignDesc_account_5fservice_2eproto(); +void protobuf_ShutdownFile_account_5fservice_2eproto(); + +class GetAccountRequest; +class GetAccountResponse; +class CreateGameAccountRequest; +class CacheExpireRequest; +class CredentialUpdateRequest; +class CredentialUpdateResponse; +class AccountFlagUpdateRequest; +class GameAccountFlagUpdateRequest; +class SubscriptionUpdateRequest; +class SubscriptionUpdateResponse; +class IsIgrAddressRequest; +class AccountServiceRegion; +class AccountServiceConfig; +class GetAccountStateRequest; +class GetAccountStateResponse; +class GetGameAccountStateRequest; +class GetGameAccountStateResponse; +class GetLicensesRequest; +class GetLicensesResponse; +class GetGameSessionInfoRequest; +class GetGameSessionInfoResponse; +class GetGameTimeRemainingInfoRequest; +class GetGameTimeRemainingInfoResponse; +class GetCAISInfoRequest; +class GetCAISInfoResponse; +class ForwardCacheExpireRequest; +class GetAuthorizedDataRequest; +class GetAuthorizedDataResponse; +class AccountStateNotification; +class GameAccountStateNotification; +class GameAccountNotification; +class GameAccountSessionNotification; + +// =================================================================== + +class TC_SHARED_API GetAccountRequest : public ::google::protobuf::Message { + public: + GetAccountRequest(); + virtual ~GetAccountRequest(); + + GetAccountRequest(const GetAccountRequest& from); + + inline GetAccountRequest& operator=(const GetAccountRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GetAccountRequest& default_instance(); + + void Swap(GetAccountRequest* other); + + // implements Message ---------------------------------------------- + + GetAccountRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GetAccountRequest& from); + void MergeFrom(const GetAccountRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.account.v1.AccountReference ref = 1; + inline bool has_ref() const; + inline void clear_ref(); + static const int kRefFieldNumber = 1; + inline const ::bgs::protocol::account::v1::AccountReference& ref() const; + inline ::bgs::protocol::account::v1::AccountReference* mutable_ref(); + inline ::bgs::protocol::account::v1::AccountReference* release_ref(); + inline void set_allocated_ref(::bgs::protocol::account::v1::AccountReference* ref); + + // optional bool fetch_all = 10 [default = false]; + inline bool has_fetch_all() const; + inline void clear_fetch_all(); + static const int kFetchAllFieldNumber = 10; + inline bool fetch_all() const; + inline void set_fetch_all(bool value); + + // optional bool fetch_blob = 11 [default = false]; + inline bool has_fetch_blob() const; + inline void clear_fetch_blob(); + static const int kFetchBlobFieldNumber = 11; + inline bool fetch_blob() const; + inline void set_fetch_blob(bool value); + + // optional bool fetch_id = 12 [default = false]; + inline bool has_fetch_id() const; + inline void clear_fetch_id(); + static const int kFetchIdFieldNumber = 12; + inline bool fetch_id() const; + inline void set_fetch_id(bool value); + + // optional bool fetch_email = 13 [default = false]; + inline bool has_fetch_email() const; + inline void clear_fetch_email(); + static const int kFetchEmailFieldNumber = 13; + inline bool fetch_email() const; + inline void set_fetch_email(bool value); + + // optional bool fetch_battle_tag = 14 [default = false]; + inline bool has_fetch_battle_tag() const; + inline void clear_fetch_battle_tag(); + static const int kFetchBattleTagFieldNumber = 14; + inline bool fetch_battle_tag() const; + inline void set_fetch_battle_tag(bool value); + + // optional bool fetch_full_name = 15 [default = false]; + inline bool has_fetch_full_name() const; + inline void clear_fetch_full_name(); + static const int kFetchFullNameFieldNumber = 15; + inline bool fetch_full_name() const; + inline void set_fetch_full_name(bool value); + + // optional bool fetch_links = 16 [default = false]; + inline bool has_fetch_links() const; + inline void clear_fetch_links(); + static const int kFetchLinksFieldNumber = 16; + inline bool fetch_links() const; + inline void set_fetch_links(bool value); + + // optional bool fetch_parental_controls = 17 [default = false]; + inline bool has_fetch_parental_controls() const; + inline void clear_fetch_parental_controls(); + static const int kFetchParentalControlsFieldNumber = 17; + inline bool fetch_parental_controls() const; + inline void set_fetch_parental_controls(bool value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAccountRequest) + private: + inline void set_has_ref(); + inline void clear_has_ref(); + inline void set_has_fetch_all(); + inline void clear_has_fetch_all(); + inline void set_has_fetch_blob(); + inline void clear_has_fetch_blob(); + inline void set_has_fetch_id(); + inline void clear_has_fetch_id(); + inline void set_has_fetch_email(); + inline void clear_has_fetch_email(); + inline void set_has_fetch_battle_tag(); + inline void clear_has_fetch_battle_tag(); + inline void set_has_fetch_full_name(); + inline void clear_has_fetch_full_name(); + inline void set_has_fetch_links(); + inline void clear_has_fetch_links(); + inline void set_has_fetch_parental_controls(); + inline void clear_has_fetch_parental_controls(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::account::v1::AccountReference* ref_; + bool fetch_all_; + bool fetch_blob_; + bool fetch_id_; + bool fetch_email_; + bool fetch_battle_tag_; + bool fetch_full_name_; + bool fetch_links_; + bool fetch_parental_controls_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GetAccountRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GetAccountResponse : public ::google::protobuf::Message { + public: + GetAccountResponse(); + virtual ~GetAccountResponse(); + + GetAccountResponse(const GetAccountResponse& from); + + inline GetAccountResponse& operator=(const GetAccountResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GetAccountResponse& default_instance(); + + void Swap(GetAccountResponse* other); + + // implements Message ---------------------------------------------- + + GetAccountResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GetAccountResponse& from); + void MergeFrom(const GetAccountResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.account.v1.AccountBlob blob = 11; + inline bool has_blob() const; + inline void clear_blob(); + static const int kBlobFieldNumber = 11; + inline const ::bgs::protocol::account::v1::AccountBlob& blob() const; + inline ::bgs::protocol::account::v1::AccountBlob* mutable_blob(); + inline ::bgs::protocol::account::v1::AccountBlob* release_blob(); + inline void set_allocated_blob(::bgs::protocol::account::v1::AccountBlob* blob); + + // optional .bgs.protocol.account.v1.AccountId id = 12; + inline bool has_id() const; + inline void clear_id(); + static const int kIdFieldNumber = 12; + inline const ::bgs::protocol::account::v1::AccountId& id() const; + inline ::bgs::protocol::account::v1::AccountId* mutable_id(); + inline ::bgs::protocol::account::v1::AccountId* release_id(); + inline void set_allocated_id(::bgs::protocol::account::v1::AccountId* id); + + // repeated string email = 13; + inline int email_size() const; + inline void clear_email(); + static const int kEmailFieldNumber = 13; + inline const ::std::string& email(int index) const; + inline ::std::string* mutable_email(int index); + inline void set_email(int index, const ::std::string& value); + inline void set_email(int index, const char* value); + inline void set_email(int index, const char* value, size_t size); + inline ::std::string* add_email(); + inline void add_email(const ::std::string& value); + inline void add_email(const char* value); + inline void add_email(const char* value, size_t size); + inline const ::google::protobuf::RepeatedPtrField< ::std::string>& email() const; + inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_email(); + + // optional string battle_tag = 14; + inline bool has_battle_tag() const; + inline void clear_battle_tag(); + static const int kBattleTagFieldNumber = 14; + inline const ::std::string& battle_tag() const; + inline void set_battle_tag(const ::std::string& value); + inline void set_battle_tag(const char* value); + inline void set_battle_tag(const char* value, size_t size); + inline ::std::string* mutable_battle_tag(); + inline ::std::string* release_battle_tag(); + inline void set_allocated_battle_tag(::std::string* battle_tag); + + // optional string full_name = 15; + inline bool has_full_name() const; + inline void clear_full_name(); + static const int kFullNameFieldNumber = 15; + inline const ::std::string& full_name() const; + inline void set_full_name(const ::std::string& value); + inline void set_full_name(const char* value); + inline void set_full_name(const char* value, size_t size); + inline ::std::string* mutable_full_name(); + inline ::std::string* release_full_name(); + inline void set_allocated_full_name(::std::string* full_name); + + // repeated .bgs.protocol.account.v1.GameAccountLink links = 16; + inline int links_size() const; + inline void clear_links(); + static const int kLinksFieldNumber = 16; + inline const ::bgs::protocol::account::v1::GameAccountLink& links(int index) const; + inline ::bgs::protocol::account::v1::GameAccountLink* mutable_links(int index); + inline ::bgs::protocol::account::v1::GameAccountLink* add_links(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink >& + links() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink >* + mutable_links(); + + // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 17; + inline bool has_parental_control_info() const; + inline void clear_parental_control_info(); + static const int kParentalControlInfoFieldNumber = 17; + inline const ::bgs::protocol::account::v1::ParentalControlInfo& parental_control_info() const; + inline ::bgs::protocol::account::v1::ParentalControlInfo* mutable_parental_control_info(); + inline ::bgs::protocol::account::v1::ParentalControlInfo* release_parental_control_info(); + inline void set_allocated_parental_control_info(::bgs::protocol::account::v1::ParentalControlInfo* parental_control_info); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAccountResponse) + private: + inline void set_has_blob(); + inline void clear_has_blob(); + inline void set_has_id(); + inline void clear_has_id(); + inline void set_has_battle_tag(); + inline void clear_has_battle_tag(); + inline void set_has_full_name(); + inline void clear_has_full_name(); + inline void set_has_parental_control_info(); + inline void clear_has_parental_control_info(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::account::v1::AccountBlob* blob_; + ::bgs::protocol::account::v1::AccountId* id_; + ::google::protobuf::RepeatedPtrField< ::std::string> email_; + ::std::string* battle_tag_; + ::std::string* full_name_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink > links_; + ::bgs::protocol::account::v1::ParentalControlInfo* parental_control_info_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GetAccountResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API CreateGameAccountRequest : public ::google::protobuf::Message { + public: + CreateGameAccountRequest(); + virtual ~CreateGameAccountRequest(); + + CreateGameAccountRequest(const CreateGameAccountRequest& from); + + inline CreateGameAccountRequest& operator=(const CreateGameAccountRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const CreateGameAccountRequest& default_instance(); + + void Swap(CreateGameAccountRequest* other); + + // implements Message ---------------------------------------------- + + CreateGameAccountRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const CreateGameAccountRequest& from); + void MergeFrom(const CreateGameAccountRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.account.v1.AccountId account = 1; + inline bool has_account() const; + inline void clear_account(); + static const int kAccountFieldNumber = 1; + inline const ::bgs::protocol::account::v1::AccountId& account() const; + inline ::bgs::protocol::account::v1::AccountId* mutable_account(); + inline ::bgs::protocol::account::v1::AccountId* release_account(); + inline void set_allocated_account(::bgs::protocol::account::v1::AccountId* account); + + // optional uint32 region = 2; + inline bool has_region() const; + inline void clear_region(); + static const int kRegionFieldNumber = 2; + inline ::google::protobuf::uint32 region() const; + inline void set_region(::google::protobuf::uint32 value); + + // optional fixed32 program = 3; + inline bool has_program() const; + inline void clear_program(); + static const int kProgramFieldNumber = 3; + inline ::google::protobuf::uint32 program() const; + inline void set_program(::google::protobuf::uint32 value); + + // optional uint32 realm_permissions = 4 [default = 1]; + inline bool has_realm_permissions() const; + inline void clear_realm_permissions(); + static const int kRealmPermissionsFieldNumber = 4; + inline ::google::protobuf::uint32 realm_permissions() const; + inline void set_realm_permissions(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.CreateGameAccountRequest) + private: + inline void set_has_account(); + inline void clear_has_account(); + inline void set_has_region(); + inline void clear_has_region(); + inline void set_has_program(); + inline void clear_has_program(); + inline void set_has_realm_permissions(); + inline void clear_has_realm_permissions(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::account::v1::AccountId* account_; + ::google::protobuf::uint32 region_; + ::google::protobuf::uint32 program_; + ::google::protobuf::uint32 realm_permissions_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static CreateGameAccountRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API CacheExpireRequest : public ::google::protobuf::Message { + public: + CacheExpireRequest(); + virtual ~CacheExpireRequest(); + + CacheExpireRequest(const CacheExpireRequest& from); + + inline CacheExpireRequest& operator=(const CacheExpireRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const CacheExpireRequest& default_instance(); + + void Swap(CacheExpireRequest* other); + + // implements Message ---------------------------------------------- + + CacheExpireRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const CacheExpireRequest& from); + void MergeFrom(const CacheExpireRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.account.v1.AccountId account = 1; + inline int account_size() const; + inline void clear_account(); + static const int kAccountFieldNumber = 1; + inline const ::bgs::protocol::account::v1::AccountId& account(int index) const; + inline ::bgs::protocol::account::v1::AccountId* mutable_account(int index); + inline ::bgs::protocol::account::v1::AccountId* add_account(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountId >& + account() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountId >* + mutable_account(); + + // repeated .bgs.protocol.account.v1.GameAccountHandle game_account = 2; + inline int game_account_size() const; + inline void clear_game_account(); + static const int kGameAccountFieldNumber = 2; + inline const ::bgs::protocol::account::v1::GameAccountHandle& game_account(int index) const; + inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_game_account(int index); + inline ::bgs::protocol::account::v1::GameAccountHandle* add_game_account(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle >& + game_account() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle >* + mutable_game_account(); + + // repeated string email = 3; + inline int email_size() const; + inline void clear_email(); + static const int kEmailFieldNumber = 3; + inline const ::std::string& email(int index) const; + inline ::std::string* mutable_email(int index); + inline void set_email(int index, const ::std::string& value); + inline void set_email(int index, const char* value); + inline void set_email(int index, const char* value, size_t size); + inline ::std::string* add_email(); + inline void add_email(const ::std::string& value); + inline void add_email(const char* value); + inline void add_email(const char* value, size_t size); + inline const ::google::protobuf::RepeatedPtrField< ::std::string>& email() const; + inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_email(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.CacheExpireRequest) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountId > account_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle > game_account_; + ::google::protobuf::RepeatedPtrField< ::std::string> email_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static CacheExpireRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API CredentialUpdateRequest : public ::google::protobuf::Message { + public: + CredentialUpdateRequest(); + virtual ~CredentialUpdateRequest(); + + CredentialUpdateRequest(const CredentialUpdateRequest& from); + + inline CredentialUpdateRequest& operator=(const CredentialUpdateRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const CredentialUpdateRequest& default_instance(); + + void Swap(CredentialUpdateRequest* other); + + // implements Message ---------------------------------------------- + + CredentialUpdateRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const CredentialUpdateRequest& from); + void MergeFrom(const CredentialUpdateRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.account.v1.AccountId account = 1; + inline bool has_account() const; + inline void clear_account(); + static const int kAccountFieldNumber = 1; + inline const ::bgs::protocol::account::v1::AccountId& account() const; + inline ::bgs::protocol::account::v1::AccountId* mutable_account(); + inline ::bgs::protocol::account::v1::AccountId* release_account(); + inline void set_allocated_account(::bgs::protocol::account::v1::AccountId* account); + + // repeated .bgs.protocol.account.v1.AccountCredential old_credentials = 2; + inline int old_credentials_size() const; + inline void clear_old_credentials(); + static const int kOldCredentialsFieldNumber = 2; + inline const ::bgs::protocol::account::v1::AccountCredential& old_credentials(int index) const; + inline ::bgs::protocol::account::v1::AccountCredential* mutable_old_credentials(int index); + inline ::bgs::protocol::account::v1::AccountCredential* add_old_credentials(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >& + old_credentials() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >* + mutable_old_credentials(); + + // repeated .bgs.protocol.account.v1.AccountCredential new_credentials = 3; + inline int new_credentials_size() const; + inline void clear_new_credentials(); + static const int kNewCredentialsFieldNumber = 3; + inline const ::bgs::protocol::account::v1::AccountCredential& new_credentials(int index) const; + inline ::bgs::protocol::account::v1::AccountCredential* mutable_new_credentials(int index); + inline ::bgs::protocol::account::v1::AccountCredential* add_new_credentials(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >& + new_credentials() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >* + mutable_new_credentials(); + + // optional uint32 region = 4; + inline bool has_region() const; + inline void clear_region(); + static const int kRegionFieldNumber = 4; + inline ::google::protobuf::uint32 region() const; + inline void set_region(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.CredentialUpdateRequest) + private: + inline void set_has_account(); + inline void clear_has_account(); + inline void set_has_region(); + inline void clear_has_region(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::account::v1::AccountId* account_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential > old_credentials_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential > new_credentials_; + ::google::protobuf::uint32 region_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static CredentialUpdateRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API CredentialUpdateResponse : public ::google::protobuf::Message { + public: + CredentialUpdateResponse(); + virtual ~CredentialUpdateResponse(); + + CredentialUpdateResponse(const CredentialUpdateResponse& from); + + inline CredentialUpdateResponse& operator=(const CredentialUpdateResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const CredentialUpdateResponse& default_instance(); + + void Swap(CredentialUpdateResponse* other); + + // implements Message ---------------------------------------------- + + CredentialUpdateResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const CredentialUpdateResponse& from); + void MergeFrom(const CredentialUpdateResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.CredentialUpdateResponse) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static CredentialUpdateResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API AccountFlagUpdateRequest : public ::google::protobuf::Message { + public: + AccountFlagUpdateRequest(); + virtual ~AccountFlagUpdateRequest(); + + AccountFlagUpdateRequest(const AccountFlagUpdateRequest& from); + + inline AccountFlagUpdateRequest& operator=(const AccountFlagUpdateRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AccountFlagUpdateRequest& default_instance(); + + void Swap(AccountFlagUpdateRequest* other); + + // implements Message ---------------------------------------------- + + AccountFlagUpdateRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AccountFlagUpdateRequest& from); + void MergeFrom(const AccountFlagUpdateRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.account.v1.AccountId account = 1; + inline bool has_account() const; + inline void clear_account(); + static const int kAccountFieldNumber = 1; + inline const ::bgs::protocol::account::v1::AccountId& account() const; + inline ::bgs::protocol::account::v1::AccountId* mutable_account(); + inline ::bgs::protocol::account::v1::AccountId* release_account(); + inline void set_allocated_account(::bgs::protocol::account::v1::AccountId* account); + + // optional uint32 region = 2; + inline bool has_region() const; + inline void clear_region(); + static const int kRegionFieldNumber = 2; + inline ::google::protobuf::uint32 region() const; + inline void set_region(::google::protobuf::uint32 value); + + // optional uint64 flag = 3; + inline bool has_flag() const; + inline void clear_flag(); + static const int kFlagFieldNumber = 3; + inline ::google::protobuf::uint64 flag() const; + inline void set_flag(::google::protobuf::uint64 value); + + // optional bool active = 4; + inline bool has_active() const; + inline void clear_active(); + static const int kActiveFieldNumber = 4; + inline bool active() const; + inline void set_active(bool value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountFlagUpdateRequest) + private: + inline void set_has_account(); + inline void clear_has_account(); + inline void set_has_region(); + inline void clear_has_region(); + inline void set_has_flag(); + inline void clear_has_flag(); + inline void set_has_active(); + inline void clear_has_active(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::account::v1::AccountId* account_; + ::google::protobuf::uint64 flag_; + ::google::protobuf::uint32 region_; + bool active_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static AccountFlagUpdateRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GameAccountFlagUpdateRequest : public ::google::protobuf::Message { + public: + GameAccountFlagUpdateRequest(); + virtual ~GameAccountFlagUpdateRequest(); + + GameAccountFlagUpdateRequest(const GameAccountFlagUpdateRequest& from); + + inline GameAccountFlagUpdateRequest& operator=(const GameAccountFlagUpdateRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GameAccountFlagUpdateRequest& default_instance(); + + void Swap(GameAccountFlagUpdateRequest* other); + + // implements Message ---------------------------------------------- + + GameAccountFlagUpdateRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GameAccountFlagUpdateRequest& from); + void MergeFrom(const GameAccountFlagUpdateRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1; + inline bool has_game_account() const; + inline void clear_game_account(); + static const int kGameAccountFieldNumber = 1; + inline const ::bgs::protocol::account::v1::GameAccountHandle& game_account() const; + inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_game_account(); + inline ::bgs::protocol::account::v1::GameAccountHandle* release_game_account(); + inline void set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account); + + // optional uint64 flag = 2; + inline bool has_flag() const; + inline void clear_flag(); + static const int kFlagFieldNumber = 2; + inline ::google::protobuf::uint64 flag() const; + inline void set_flag(::google::protobuf::uint64 value); + + // optional bool active = 3; + inline bool has_active() const; + inline void clear_active(); + static const int kActiveFieldNumber = 3; + inline bool active() const; + inline void set_active(bool value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountFlagUpdateRequest) + private: + inline void set_has_game_account(); + inline void clear_has_game_account(); + inline void set_has_flag(); + inline void clear_has_flag(); + inline void set_has_active(); + inline void clear_has_active(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::account::v1::GameAccountHandle* game_account_; + ::google::protobuf::uint64 flag_; + bool active_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GameAccountFlagUpdateRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API SubscriptionUpdateRequest : public ::google::protobuf::Message { + public: + SubscriptionUpdateRequest(); + virtual ~SubscriptionUpdateRequest(); + + SubscriptionUpdateRequest(const SubscriptionUpdateRequest& from); + + inline SubscriptionUpdateRequest& operator=(const SubscriptionUpdateRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SubscriptionUpdateRequest& default_instance(); + + void Swap(SubscriptionUpdateRequest* other); + + // implements Message ---------------------------------------------- + + SubscriptionUpdateRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SubscriptionUpdateRequest& from); + void MergeFrom(const SubscriptionUpdateRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.account.v1.SubscriberReference ref = 2; + inline int ref_size() const; + inline void clear_ref(); + static const int kRefFieldNumber = 2; + inline const ::bgs::protocol::account::v1::SubscriberReference& ref(int index) const; + inline ::bgs::protocol::account::v1::SubscriberReference* mutable_ref(int index); + inline ::bgs::protocol::account::v1::SubscriberReference* add_ref(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference >& + ref() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference >* + mutable_ref(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.SubscriptionUpdateRequest) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference > ref_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static SubscriptionUpdateRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API SubscriptionUpdateResponse : public ::google::protobuf::Message { + public: + SubscriptionUpdateResponse(); + virtual ~SubscriptionUpdateResponse(); + + SubscriptionUpdateResponse(const SubscriptionUpdateResponse& from); + + inline SubscriptionUpdateResponse& operator=(const SubscriptionUpdateResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SubscriptionUpdateResponse& default_instance(); + + void Swap(SubscriptionUpdateResponse* other); + + // implements Message ---------------------------------------------- + + SubscriptionUpdateResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SubscriptionUpdateResponse& from); + void MergeFrom(const SubscriptionUpdateResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.account.v1.SubscriberReference ref = 1; + inline int ref_size() const; + inline void clear_ref(); + static const int kRefFieldNumber = 1; + inline const ::bgs::protocol::account::v1::SubscriberReference& ref(int index) const; + inline ::bgs::protocol::account::v1::SubscriberReference* mutable_ref(int index); + inline ::bgs::protocol::account::v1::SubscriberReference* add_ref(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference >& + ref() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference >* + mutable_ref(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.SubscriptionUpdateResponse) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference > ref_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static SubscriptionUpdateResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API IsIgrAddressRequest : public ::google::protobuf::Message { + public: + IsIgrAddressRequest(); + virtual ~IsIgrAddressRequest(); + + IsIgrAddressRequest(const IsIgrAddressRequest& from); + + inline IsIgrAddressRequest& operator=(const IsIgrAddressRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const IsIgrAddressRequest& default_instance(); + + void Swap(IsIgrAddressRequest* other); + + // implements Message ---------------------------------------------- + + IsIgrAddressRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const IsIgrAddressRequest& from); + void MergeFrom(const IsIgrAddressRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string client_address = 1; + inline bool has_client_address() const; + inline void clear_client_address(); + static const int kClientAddressFieldNumber = 1; + inline const ::std::string& client_address() const; + inline void set_client_address(const ::std::string& value); + inline void set_client_address(const char* value); + inline void set_client_address(const char* value, size_t size); + inline ::std::string* mutable_client_address(); + inline ::std::string* release_client_address(); + inline void set_allocated_client_address(::std::string* client_address); + + // optional uint32 region = 2; + inline bool has_region() const; + inline void clear_region(); + static const int kRegionFieldNumber = 2; + inline ::google::protobuf::uint32 region() const; + inline void set_region(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.IsIgrAddressRequest) + private: + inline void set_has_client_address(); + inline void clear_has_client_address(); + inline void set_has_region(); + inline void clear_has_region(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* client_address_; + ::google::protobuf::uint32 region_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static IsIgrAddressRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API AccountServiceRegion : public ::google::protobuf::Message { + public: + AccountServiceRegion(); + virtual ~AccountServiceRegion(); + + AccountServiceRegion(const AccountServiceRegion& from); + + inline AccountServiceRegion& operator=(const AccountServiceRegion& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AccountServiceRegion& default_instance(); + + void Swap(AccountServiceRegion* other); + + // implements Message ---------------------------------------------- + + AccountServiceRegion* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AccountServiceRegion& from); + void MergeFrom(const AccountServiceRegion& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required uint32 id = 1; + inline bool has_id() const; + inline void clear_id(); + static const int kIdFieldNumber = 1; + inline ::google::protobuf::uint32 id() const; + inline void set_id(::google::protobuf::uint32 value); + + // required string shard = 2; + inline bool has_shard() const; + inline void clear_shard(); + static const int kShardFieldNumber = 2; + inline const ::std::string& shard() const; + inline void set_shard(const ::std::string& value); + inline void set_shard(const char* value); + inline void set_shard(const char* value, size_t size); + inline ::std::string* mutable_shard(); + inline ::std::string* release_shard(); + inline void set_allocated_shard(::std::string* shard); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountServiceRegion) + private: + inline void set_has_id(); + inline void clear_has_id(); + inline void set_has_shard(); + inline void clear_has_shard(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* shard_; + ::google::protobuf::uint32 id_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static AccountServiceRegion* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API AccountServiceConfig : public ::google::protobuf::Message { + public: + AccountServiceConfig(); + virtual ~AccountServiceConfig(); + + AccountServiceConfig(const AccountServiceConfig& from); + + inline AccountServiceConfig& operator=(const AccountServiceConfig& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AccountServiceConfig& default_instance(); + + void Swap(AccountServiceConfig* other); + + // implements Message ---------------------------------------------- + + AccountServiceConfig* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AccountServiceConfig& from); + void MergeFrom(const AccountServiceConfig& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.account.v1.AccountServiceRegion region = 1; + inline int region_size() const; + inline void clear_region(); + static const int kRegionFieldNumber = 1; + inline const ::bgs::protocol::account::v1::AccountServiceRegion& region(int index) const; + inline ::bgs::protocol::account::v1::AccountServiceRegion* mutable_region(int index); + inline ::bgs::protocol::account::v1::AccountServiceRegion* add_region(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountServiceRegion >& + region() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountServiceRegion >* + mutable_region(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountServiceConfig) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountServiceRegion > region_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static AccountServiceConfig* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GetAccountStateRequest : public ::google::protobuf::Message { + public: + GetAccountStateRequest(); + virtual ~GetAccountStateRequest(); + + GetAccountStateRequest(const GetAccountStateRequest& from); + + inline GetAccountStateRequest& operator=(const GetAccountStateRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GetAccountStateRequest& default_instance(); + + void Swap(GetAccountStateRequest* other); + + // implements Message ---------------------------------------------- + + GetAccountStateRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GetAccountStateRequest& from); + void MergeFrom(const GetAccountStateRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId entity_id = 1; + inline bool has_entity_id() const; + inline void clear_entity_id(); + static const int kEntityIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& entity_id() const; + inline ::bgs::protocol::EntityId* mutable_entity_id(); + inline ::bgs::protocol::EntityId* release_entity_id(); + inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id); + + // optional uint32 program = 2; + inline bool has_program() const; + inline void clear_program(); + static const int kProgramFieldNumber = 2; + inline ::google::protobuf::uint32 program() const; + inline void set_program(::google::protobuf::uint32 value); + + // optional uint32 region = 3; + inline bool has_region() const; + inline void clear_region(); + static const int kRegionFieldNumber = 3; + inline ::google::protobuf::uint32 region() const; + inline void set_region(::google::protobuf::uint32 value); + + // optional .bgs.protocol.account.v1.AccountFieldOptions options = 10; + inline bool has_options() const; + inline void clear_options(); + static const int kOptionsFieldNumber = 10; + inline const ::bgs::protocol::account::v1::AccountFieldOptions& options() const; + inline ::bgs::protocol::account::v1::AccountFieldOptions* mutable_options(); + inline ::bgs::protocol::account::v1::AccountFieldOptions* release_options(); + inline void set_allocated_options(::bgs::protocol::account::v1::AccountFieldOptions* options); + + // optional .bgs.protocol.account.v1.AccountFieldTags tags = 11; + inline bool has_tags() const; + inline void clear_tags(); + static const int kTagsFieldNumber = 11; + inline const ::bgs::protocol::account::v1::AccountFieldTags& tags() const; + inline ::bgs::protocol::account::v1::AccountFieldTags* mutable_tags(); + inline ::bgs::protocol::account::v1::AccountFieldTags* release_tags(); + inline void set_allocated_tags(::bgs::protocol::account::v1::AccountFieldTags* tags); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAccountStateRequest) + private: + inline void set_has_entity_id(); + inline void clear_has_entity_id(); + inline void set_has_program(); + inline void clear_has_program(); + inline void set_has_region(); + inline void clear_has_region(); + inline void set_has_options(); + inline void clear_has_options(); + inline void set_has_tags(); + inline void clear_has_tags(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* entity_id_; + ::google::protobuf::uint32 program_; + ::google::protobuf::uint32 region_; + ::bgs::protocol::account::v1::AccountFieldOptions* options_; + ::bgs::protocol::account::v1::AccountFieldTags* tags_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GetAccountStateRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GetAccountStateResponse : public ::google::protobuf::Message { + public: + GetAccountStateResponse(); + virtual ~GetAccountStateResponse(); + + GetAccountStateResponse(const GetAccountStateResponse& from); + + inline GetAccountStateResponse& operator=(const GetAccountStateResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GetAccountStateResponse& default_instance(); + + void Swap(GetAccountStateResponse* other); + + // implements Message ---------------------------------------------- + + GetAccountStateResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GetAccountStateResponse& from); + void MergeFrom(const GetAccountStateResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.account.v1.AccountState state = 1; + inline bool has_state() const; + inline void clear_state(); + static const int kStateFieldNumber = 1; + inline const ::bgs::protocol::account::v1::AccountState& state() const; + inline ::bgs::protocol::account::v1::AccountState* mutable_state(); + inline ::bgs::protocol::account::v1::AccountState* release_state(); + inline void set_allocated_state(::bgs::protocol::account::v1::AccountState* state); + + // optional .bgs.protocol.account.v1.AccountFieldTags tags = 2; + inline bool has_tags() const; + inline void clear_tags(); + static const int kTagsFieldNumber = 2; + inline const ::bgs::protocol::account::v1::AccountFieldTags& tags() const; + inline ::bgs::protocol::account::v1::AccountFieldTags* mutable_tags(); + inline ::bgs::protocol::account::v1::AccountFieldTags* release_tags(); + inline void set_allocated_tags(::bgs::protocol::account::v1::AccountFieldTags* tags); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAccountStateResponse) + private: + inline void set_has_state(); + inline void clear_has_state(); + inline void set_has_tags(); + inline void clear_has_tags(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::account::v1::AccountState* state_; + ::bgs::protocol::account::v1::AccountFieldTags* tags_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GetAccountStateResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GetGameAccountStateRequest : public ::google::protobuf::Message { + public: + GetGameAccountStateRequest(); + virtual ~GetGameAccountStateRequest(); + + GetGameAccountStateRequest(const GetGameAccountStateRequest& from); + + inline GetGameAccountStateRequest& operator=(const GetGameAccountStateRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GetGameAccountStateRequest& default_instance(); + + void Swap(GetGameAccountStateRequest* other); + + // implements Message ---------------------------------------------- + + GetGameAccountStateRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GetGameAccountStateRequest& from); + void MergeFrom(const GetGameAccountStateRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId account_id = 1 [deprecated = true]; + inline bool has_account_id() const PROTOBUF_DEPRECATED; + inline void clear_account_id() PROTOBUF_DEPRECATED; + static const int kAccountIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& account_id() const PROTOBUF_DEPRECATED; + inline ::bgs::protocol::EntityId* mutable_account_id() PROTOBUF_DEPRECATED; + inline ::bgs::protocol::EntityId* release_account_id() PROTOBUF_DEPRECATED; + inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id) PROTOBUF_DEPRECATED; + + // optional .bgs.protocol.EntityId game_account_id = 2; + inline bool has_game_account_id() const; + inline void clear_game_account_id(); + static const int kGameAccountIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& game_account_id() const; + inline ::bgs::protocol::EntityId* mutable_game_account_id(); + inline ::bgs::protocol::EntityId* release_game_account_id(); + inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id); + + // optional .bgs.protocol.account.v1.GameAccountFieldOptions options = 10; + inline bool has_options() const; + inline void clear_options(); + static const int kOptionsFieldNumber = 10; + inline const ::bgs::protocol::account::v1::GameAccountFieldOptions& options() const; + inline ::bgs::protocol::account::v1::GameAccountFieldOptions* mutable_options(); + inline ::bgs::protocol::account::v1::GameAccountFieldOptions* release_options(); + inline void set_allocated_options(::bgs::protocol::account::v1::GameAccountFieldOptions* options); + + // optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 11; + inline bool has_tags() const; + inline void clear_tags(); + static const int kTagsFieldNumber = 11; + inline const ::bgs::protocol::account::v1::GameAccountFieldTags& tags() const; + inline ::bgs::protocol::account::v1::GameAccountFieldTags* mutable_tags(); + inline ::bgs::protocol::account::v1::GameAccountFieldTags* release_tags(); + inline void set_allocated_tags(::bgs::protocol::account::v1::GameAccountFieldTags* tags); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetGameAccountStateRequest) + private: + inline void set_has_account_id(); + inline void clear_has_account_id(); + inline void set_has_game_account_id(); + inline void clear_has_game_account_id(); + inline void set_has_options(); + inline void clear_has_options(); + inline void set_has_tags(); + inline void clear_has_tags(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* account_id_; + ::bgs::protocol::EntityId* game_account_id_; + ::bgs::protocol::account::v1::GameAccountFieldOptions* options_; + ::bgs::protocol::account::v1::GameAccountFieldTags* tags_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GetGameAccountStateRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GetGameAccountStateResponse : public ::google::protobuf::Message { + public: + GetGameAccountStateResponse(); + virtual ~GetGameAccountStateResponse(); + + GetGameAccountStateResponse(const GetGameAccountStateResponse& from); + + inline GetGameAccountStateResponse& operator=(const GetGameAccountStateResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GetGameAccountStateResponse& default_instance(); + + void Swap(GetGameAccountStateResponse* other); + + // implements Message ---------------------------------------------- + + GetGameAccountStateResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GetGameAccountStateResponse& from); + void MergeFrom(const GetGameAccountStateResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.account.v1.GameAccountState state = 1; + inline bool has_state() const; + inline void clear_state(); + static const int kStateFieldNumber = 1; + inline const ::bgs::protocol::account::v1::GameAccountState& state() const; + inline ::bgs::protocol::account::v1::GameAccountState* mutable_state(); + inline ::bgs::protocol::account::v1::GameAccountState* release_state(); + inline void set_allocated_state(::bgs::protocol::account::v1::GameAccountState* state); + + // optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 2; + inline bool has_tags() const; + inline void clear_tags(); + static const int kTagsFieldNumber = 2; + inline const ::bgs::protocol::account::v1::GameAccountFieldTags& tags() const; + inline ::bgs::protocol::account::v1::GameAccountFieldTags* mutable_tags(); + inline ::bgs::protocol::account::v1::GameAccountFieldTags* release_tags(); + inline void set_allocated_tags(::bgs::protocol::account::v1::GameAccountFieldTags* tags); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetGameAccountStateResponse) + private: + inline void set_has_state(); + inline void clear_has_state(); + inline void set_has_tags(); + inline void clear_has_tags(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::account::v1::GameAccountState* state_; + ::bgs::protocol::account::v1::GameAccountFieldTags* tags_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GetGameAccountStateResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GetLicensesRequest : public ::google::protobuf::Message { + public: + GetLicensesRequest(); + virtual ~GetLicensesRequest(); + + GetLicensesRequest(const GetLicensesRequest& from); + + inline GetLicensesRequest& operator=(const GetLicensesRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GetLicensesRequest& default_instance(); + + void Swap(GetLicensesRequest* other); + + // implements Message ---------------------------------------------- + + GetLicensesRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GetLicensesRequest& from); + void MergeFrom(const GetLicensesRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId target_id = 1; + inline bool has_target_id() const; + inline void clear_target_id(); + static const int kTargetIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& target_id() const; + inline ::bgs::protocol::EntityId* mutable_target_id(); + inline ::bgs::protocol::EntityId* release_target_id(); + inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id); + + // optional bool fetch_account_licenses = 2; + inline bool has_fetch_account_licenses() const; + inline void clear_fetch_account_licenses(); + static const int kFetchAccountLicensesFieldNumber = 2; + inline bool fetch_account_licenses() const; + inline void set_fetch_account_licenses(bool value); + + // optional bool fetch_game_account_licenses = 3; + inline bool has_fetch_game_account_licenses() const; + inline void clear_fetch_game_account_licenses(); + static const int kFetchGameAccountLicensesFieldNumber = 3; + inline bool fetch_game_account_licenses() const; + inline void set_fetch_game_account_licenses(bool value); + + // optional bool fetch_dynamic_account_licenses = 4; + inline bool has_fetch_dynamic_account_licenses() const; + inline void clear_fetch_dynamic_account_licenses(); + static const int kFetchDynamicAccountLicensesFieldNumber = 4; + inline bool fetch_dynamic_account_licenses() const; + inline void set_fetch_dynamic_account_licenses(bool value); + + // optional fixed32 program = 5; + inline bool has_program() const; + inline void clear_program(); + static const int kProgramFieldNumber = 5; + inline ::google::protobuf::uint32 program() const; + inline void set_program(::google::protobuf::uint32 value); + + // optional bool exclude_unknown_program = 6 [default = false]; + inline bool has_exclude_unknown_program() const; + inline void clear_exclude_unknown_program(); + static const int kExcludeUnknownProgramFieldNumber = 6; + inline bool exclude_unknown_program() const; + inline void set_exclude_unknown_program(bool value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetLicensesRequest) + private: + inline void set_has_target_id(); + inline void clear_has_target_id(); + inline void set_has_fetch_account_licenses(); + inline void clear_has_fetch_account_licenses(); + inline void set_has_fetch_game_account_licenses(); + inline void clear_has_fetch_game_account_licenses(); + inline void set_has_fetch_dynamic_account_licenses(); + inline void clear_has_fetch_dynamic_account_licenses(); + inline void set_has_program(); + inline void clear_has_program(); + inline void set_has_exclude_unknown_program(); + inline void clear_has_exclude_unknown_program(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* target_id_; + bool fetch_account_licenses_; + bool fetch_game_account_licenses_; + bool fetch_dynamic_account_licenses_; + bool exclude_unknown_program_; + ::google::protobuf::uint32 program_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GetLicensesRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GetLicensesResponse : public ::google::protobuf::Message { + public: + GetLicensesResponse(); + virtual ~GetLicensesResponse(); + + GetLicensesResponse(const GetLicensesResponse& from); + + inline GetLicensesResponse& operator=(const GetLicensesResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GetLicensesResponse& default_instance(); + + void Swap(GetLicensesResponse* other); + + // implements Message ---------------------------------------------- + + GetLicensesResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GetLicensesResponse& from); + void MergeFrom(const GetLicensesResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 1; + inline int licenses_size() const; + inline void clear_licenses(); + static const int kLicensesFieldNumber = 1; + inline const ::bgs::protocol::account::v1::AccountLicense& licenses(int index) const; + inline ::bgs::protocol::account::v1::AccountLicense* mutable_licenses(int index); + inline ::bgs::protocol::account::v1::AccountLicense* add_licenses(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >& + licenses() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >* + mutable_licenses(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetLicensesResponse) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense > licenses_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GetLicensesResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GetGameSessionInfoRequest : public ::google::protobuf::Message { + public: + GetGameSessionInfoRequest(); + virtual ~GetGameSessionInfoRequest(); + + GetGameSessionInfoRequest(const GetGameSessionInfoRequest& from); + + inline GetGameSessionInfoRequest& operator=(const GetGameSessionInfoRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GetGameSessionInfoRequest& default_instance(); + + void Swap(GetGameSessionInfoRequest* other); + + // implements Message ---------------------------------------------- + + GetGameSessionInfoRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GetGameSessionInfoRequest& from); + void MergeFrom(const GetGameSessionInfoRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId entity_id = 1; + inline bool has_entity_id() const; + inline void clear_entity_id(); + static const int kEntityIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& entity_id() const; + inline ::bgs::protocol::EntityId* mutable_entity_id(); + inline ::bgs::protocol::EntityId* release_entity_id(); + inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetGameSessionInfoRequest) + private: + inline void set_has_entity_id(); + inline void clear_has_entity_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* entity_id_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GetGameSessionInfoRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GetGameSessionInfoResponse : public ::google::protobuf::Message { + public: + GetGameSessionInfoResponse(); + virtual ~GetGameSessionInfoResponse(); + + GetGameSessionInfoResponse(const GetGameSessionInfoResponse& from); + + inline GetGameSessionInfoResponse& operator=(const GetGameSessionInfoResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GetGameSessionInfoResponse& default_instance(); + + void Swap(GetGameSessionInfoResponse* other); + + // implements Message ---------------------------------------------- + + GetGameSessionInfoResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GetGameSessionInfoResponse& from); + void MergeFrom(const GetGameSessionInfoResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.account.v1.GameSessionInfo session_info = 2; + inline bool has_session_info() const; + inline void clear_session_info(); + static const int kSessionInfoFieldNumber = 2; + inline const ::bgs::protocol::account::v1::GameSessionInfo& session_info() const; + inline ::bgs::protocol::account::v1::GameSessionInfo* mutable_session_info(); + inline ::bgs::protocol::account::v1::GameSessionInfo* release_session_info(); + inline void set_allocated_session_info(::bgs::protocol::account::v1::GameSessionInfo* session_info); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetGameSessionInfoResponse) + private: + inline void set_has_session_info(); + inline void clear_has_session_info(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::account::v1::GameSessionInfo* session_info_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GetGameSessionInfoResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GetGameTimeRemainingInfoRequest : public ::google::protobuf::Message { + public: + GetGameTimeRemainingInfoRequest(); + virtual ~GetGameTimeRemainingInfoRequest(); + + GetGameTimeRemainingInfoRequest(const GetGameTimeRemainingInfoRequest& from); + + inline GetGameTimeRemainingInfoRequest& operator=(const GetGameTimeRemainingInfoRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GetGameTimeRemainingInfoRequest& default_instance(); + + void Swap(GetGameTimeRemainingInfoRequest* other); + + // implements Message ---------------------------------------------- + + GetGameTimeRemainingInfoRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GetGameTimeRemainingInfoRequest& from); + void MergeFrom(const GetGameTimeRemainingInfoRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId game_account_id = 1; + inline bool has_game_account_id() const; + inline void clear_game_account_id(); + static const int kGameAccountIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& game_account_id() const; + inline ::bgs::protocol::EntityId* mutable_game_account_id(); + inline ::bgs::protocol::EntityId* release_game_account_id(); + inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id); + + // optional .bgs.protocol.EntityId account_id = 2; + inline bool has_account_id() const; + inline void clear_account_id(); + static const int kAccountIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& account_id() const; + inline ::bgs::protocol::EntityId* mutable_account_id(); + inline ::bgs::protocol::EntityId* release_account_id(); + inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest) + private: + inline void set_has_game_account_id(); + inline void clear_has_game_account_id(); + inline void set_has_account_id(); + inline void clear_has_account_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* game_account_id_; + ::bgs::protocol::EntityId* account_id_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GetGameTimeRemainingInfoRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GetGameTimeRemainingInfoResponse : public ::google::protobuf::Message { + public: + GetGameTimeRemainingInfoResponse(); + virtual ~GetGameTimeRemainingInfoResponse(); + + GetGameTimeRemainingInfoResponse(const GetGameTimeRemainingInfoResponse& from); + + inline GetGameTimeRemainingInfoResponse& operator=(const GetGameTimeRemainingInfoResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GetGameTimeRemainingInfoResponse& default_instance(); + + void Swap(GetGameTimeRemainingInfoResponse* other); + + // implements Message ---------------------------------------------- + + GetGameTimeRemainingInfoResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GetGameTimeRemainingInfoResponse& from); + void MergeFrom(const GetGameTimeRemainingInfoResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.account.v1.GameTimeRemainingInfo game_time_remaining_info = 1; + inline bool has_game_time_remaining_info() const; + inline void clear_game_time_remaining_info(); + static const int kGameTimeRemainingInfoFieldNumber = 1; + inline const ::bgs::protocol::account::v1::GameTimeRemainingInfo& game_time_remaining_info() const; + inline ::bgs::protocol::account::v1::GameTimeRemainingInfo* mutable_game_time_remaining_info(); + inline ::bgs::protocol::account::v1::GameTimeRemainingInfo* release_game_time_remaining_info(); + inline void set_allocated_game_time_remaining_info(::bgs::protocol::account::v1::GameTimeRemainingInfo* game_time_remaining_info); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse) + private: + inline void set_has_game_time_remaining_info(); + inline void clear_has_game_time_remaining_info(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::account::v1::GameTimeRemainingInfo* game_time_remaining_info_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GetGameTimeRemainingInfoResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GetCAISInfoRequest : public ::google::protobuf::Message { + public: + GetCAISInfoRequest(); + virtual ~GetCAISInfoRequest(); + + GetCAISInfoRequest(const GetCAISInfoRequest& from); + + inline GetCAISInfoRequest& operator=(const GetCAISInfoRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GetCAISInfoRequest& default_instance(); + + void Swap(GetCAISInfoRequest* other); + + // implements Message ---------------------------------------------- + + GetCAISInfoRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GetCAISInfoRequest& from); + void MergeFrom(const GetCAISInfoRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId entity_id = 1; + inline bool has_entity_id() const; + inline void clear_entity_id(); + static const int kEntityIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& entity_id() const; + inline ::bgs::protocol::EntityId* mutable_entity_id(); + inline ::bgs::protocol::EntityId* release_entity_id(); + inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetCAISInfoRequest) + private: + inline void set_has_entity_id(); + inline void clear_has_entity_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* entity_id_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GetCAISInfoRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GetCAISInfoResponse : public ::google::protobuf::Message { + public: + GetCAISInfoResponse(); + virtual ~GetCAISInfoResponse(); + + GetCAISInfoResponse(const GetCAISInfoResponse& from); + + inline GetCAISInfoResponse& operator=(const GetCAISInfoResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GetCAISInfoResponse& default_instance(); + + void Swap(GetCAISInfoResponse* other); + + // implements Message ---------------------------------------------- + + GetCAISInfoResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GetCAISInfoResponse& from); + void MergeFrom(const GetCAISInfoResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.account.v1.CAIS cais_info = 1; + inline bool has_cais_info() const; + inline void clear_cais_info(); + static const int kCaisInfoFieldNumber = 1; + inline const ::bgs::protocol::account::v1::CAIS& cais_info() const; + inline ::bgs::protocol::account::v1::CAIS* mutable_cais_info(); + inline ::bgs::protocol::account::v1::CAIS* release_cais_info(); + inline void set_allocated_cais_info(::bgs::protocol::account::v1::CAIS* cais_info); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetCAISInfoResponse) + private: + inline void set_has_cais_info(); + inline void clear_has_cais_info(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::account::v1::CAIS* cais_info_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GetCAISInfoResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ForwardCacheExpireRequest : public ::google::protobuf::Message { + public: + ForwardCacheExpireRequest(); + virtual ~ForwardCacheExpireRequest(); + + ForwardCacheExpireRequest(const ForwardCacheExpireRequest& from); + + inline ForwardCacheExpireRequest& operator=(const ForwardCacheExpireRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ForwardCacheExpireRequest& default_instance(); + + void Swap(ForwardCacheExpireRequest* other); + + // implements Message ---------------------------------------------- + + ForwardCacheExpireRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ForwardCacheExpireRequest& from); + void MergeFrom(const ForwardCacheExpireRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId entity_id = 1; + inline bool has_entity_id() const; + inline void clear_entity_id(); + static const int kEntityIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& entity_id() const; + inline ::bgs::protocol::EntityId* mutable_entity_id(); + inline ::bgs::protocol::EntityId* release_entity_id(); + inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.ForwardCacheExpireRequest) + private: + inline void set_has_entity_id(); + inline void clear_has_entity_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* entity_id_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ForwardCacheExpireRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GetAuthorizedDataRequest : public ::google::protobuf::Message { + public: + GetAuthorizedDataRequest(); + virtual ~GetAuthorizedDataRequest(); + + GetAuthorizedDataRequest(const GetAuthorizedDataRequest& from); + + inline GetAuthorizedDataRequest& operator=(const GetAuthorizedDataRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GetAuthorizedDataRequest& default_instance(); + + void Swap(GetAuthorizedDataRequest* other); + + // implements Message ---------------------------------------------- + + GetAuthorizedDataRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GetAuthorizedDataRequest& from); + void MergeFrom(const GetAuthorizedDataRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId entity_id = 1; + inline bool has_entity_id() const; + inline void clear_entity_id(); + static const int kEntityIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& entity_id() const; + inline ::bgs::protocol::EntityId* mutable_entity_id(); + inline ::bgs::protocol::EntityId* release_entity_id(); + inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id); + + // repeated string tag = 2; + inline int tag_size() const; + inline void clear_tag(); + static const int kTagFieldNumber = 2; + inline const ::std::string& tag(int index) const; + inline ::std::string* mutable_tag(int index); + inline void set_tag(int index, const ::std::string& value); + inline void set_tag(int index, const char* value); + inline void set_tag(int index, const char* value, size_t size); + inline ::std::string* add_tag(); + inline void add_tag(const ::std::string& value); + inline void add_tag(const char* value); + inline void add_tag(const char* value, size_t size); + inline const ::google::protobuf::RepeatedPtrField< ::std::string>& tag() const; + inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_tag(); + + // optional bool privileged_network = 3; + inline bool has_privileged_network() const; + inline void clear_privileged_network(); + static const int kPrivilegedNetworkFieldNumber = 3; + inline bool privileged_network() const; + inline void set_privileged_network(bool value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAuthorizedDataRequest) + private: + inline void set_has_entity_id(); + inline void clear_has_entity_id(); + inline void set_has_privileged_network(); + inline void clear_has_privileged_network(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* entity_id_; + ::google::protobuf::RepeatedPtrField< ::std::string> tag_; + bool privileged_network_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GetAuthorizedDataRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GetAuthorizedDataResponse : public ::google::protobuf::Message { + public: + GetAuthorizedDataResponse(); + virtual ~GetAuthorizedDataResponse(); + + GetAuthorizedDataResponse(const GetAuthorizedDataResponse& from); + + inline GetAuthorizedDataResponse& operator=(const GetAuthorizedDataResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GetAuthorizedDataResponse& default_instance(); + + void Swap(GetAuthorizedDataResponse* other); + + // implements Message ---------------------------------------------- + + GetAuthorizedDataResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GetAuthorizedDataResponse& from); + void MergeFrom(const GetAuthorizedDataResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.account.v1.AuthorizedData data = 1; + inline int data_size() const; + inline void clear_data(); + static const int kDataFieldNumber = 1; + inline const ::bgs::protocol::account::v1::AuthorizedData& data(int index) const; + inline ::bgs::protocol::account::v1::AuthorizedData* mutable_data(int index); + inline ::bgs::protocol::account::v1::AuthorizedData* add_data(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AuthorizedData >& + data() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AuthorizedData >* + mutable_data(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAuthorizedDataResponse) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AuthorizedData > data_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GetAuthorizedDataResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API AccountStateNotification : public ::google::protobuf::Message { + public: + AccountStateNotification(); + virtual ~AccountStateNotification(); + + AccountStateNotification(const AccountStateNotification& from); + + inline AccountStateNotification& operator=(const AccountStateNotification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AccountStateNotification& default_instance(); + + void Swap(AccountStateNotification* other); + + // implements Message ---------------------------------------------- + + AccountStateNotification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AccountStateNotification& from); + void MergeFrom(const AccountStateNotification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.account.v1.AccountState account_state = 1; + inline bool has_account_state() const; + inline void clear_account_state(); + static const int kAccountStateFieldNumber = 1; + inline const ::bgs::protocol::account::v1::AccountState& account_state() const; + inline ::bgs::protocol::account::v1::AccountState* mutable_account_state(); + inline ::bgs::protocol::account::v1::AccountState* release_account_state(); + inline void set_allocated_account_state(::bgs::protocol::account::v1::AccountState* account_state); + + // optional uint64 subscriber_id = 2; + inline bool has_subscriber_id() const; + inline void clear_subscriber_id(); + static const int kSubscriberIdFieldNumber = 2; + inline ::google::protobuf::uint64 subscriber_id() const; + inline void set_subscriber_id(::google::protobuf::uint64 value); + + // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3; + inline bool has_account_tags() const; + inline void clear_account_tags(); + static const int kAccountTagsFieldNumber = 3; + inline const ::bgs::protocol::account::v1::AccountFieldTags& account_tags() const; + inline ::bgs::protocol::account::v1::AccountFieldTags* mutable_account_tags(); + inline ::bgs::protocol::account::v1::AccountFieldTags* release_account_tags(); + inline void set_allocated_account_tags(::bgs::protocol::account::v1::AccountFieldTags* account_tags); + + // optional bool subscription_completed = 4; + inline bool has_subscription_completed() const; + inline void clear_subscription_completed(); + static const int kSubscriptionCompletedFieldNumber = 4; + inline bool subscription_completed() const; + inline void set_subscription_completed(bool value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountStateNotification) + private: + inline void set_has_account_state(); + inline void clear_has_account_state(); + inline void set_has_subscriber_id(); + inline void clear_has_subscriber_id(); + inline void set_has_account_tags(); + inline void clear_has_account_tags(); + inline void set_has_subscription_completed(); + inline void clear_has_subscription_completed(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::account::v1::AccountState* account_state_; + ::google::protobuf::uint64 subscriber_id_; + ::bgs::protocol::account::v1::AccountFieldTags* account_tags_; + bool subscription_completed_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static AccountStateNotification* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GameAccountStateNotification : public ::google::protobuf::Message { + public: + GameAccountStateNotification(); + virtual ~GameAccountStateNotification(); + + GameAccountStateNotification(const GameAccountStateNotification& from); + + inline GameAccountStateNotification& operator=(const GameAccountStateNotification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GameAccountStateNotification& default_instance(); + + void Swap(GameAccountStateNotification* other); + + // implements Message ---------------------------------------------- + + GameAccountStateNotification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GameAccountStateNotification& from); + void MergeFrom(const GameAccountStateNotification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.account.v1.GameAccountState game_account_state = 1; + inline bool has_game_account_state() const; + inline void clear_game_account_state(); + static const int kGameAccountStateFieldNumber = 1; + inline const ::bgs::protocol::account::v1::GameAccountState& game_account_state() const; + inline ::bgs::protocol::account::v1::GameAccountState* mutable_game_account_state(); + inline ::bgs::protocol::account::v1::GameAccountState* release_game_account_state(); + inline void set_allocated_game_account_state(::bgs::protocol::account::v1::GameAccountState* game_account_state); + + // optional uint64 subscriber_id = 2; + inline bool has_subscriber_id() const; + inline void clear_subscriber_id(); + static const int kSubscriberIdFieldNumber = 2; + inline ::google::protobuf::uint64 subscriber_id() const; + inline void set_subscriber_id(::google::protobuf::uint64 value); + + // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 3; + inline bool has_game_account_tags() const; + inline void clear_game_account_tags(); + static const int kGameAccountTagsFieldNumber = 3; + inline const ::bgs::protocol::account::v1::GameAccountFieldTags& game_account_tags() const; + inline ::bgs::protocol::account::v1::GameAccountFieldTags* mutable_game_account_tags(); + inline ::bgs::protocol::account::v1::GameAccountFieldTags* release_game_account_tags(); + inline void set_allocated_game_account_tags(::bgs::protocol::account::v1::GameAccountFieldTags* game_account_tags); + + // optional bool subscription_completed = 4; + inline bool has_subscription_completed() const; + inline void clear_subscription_completed(); + static const int kSubscriptionCompletedFieldNumber = 4; + inline bool subscription_completed() const; + inline void set_subscription_completed(bool value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountStateNotification) + private: + inline void set_has_game_account_state(); + inline void clear_has_game_account_state(); + inline void set_has_subscriber_id(); + inline void clear_has_subscriber_id(); + inline void set_has_game_account_tags(); + inline void clear_has_game_account_tags(); + inline void set_has_subscription_completed(); + inline void clear_has_subscription_completed(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::account::v1::GameAccountState* game_account_state_; + ::google::protobuf::uint64 subscriber_id_; + ::bgs::protocol::account::v1::GameAccountFieldTags* game_account_tags_; + bool subscription_completed_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GameAccountStateNotification* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GameAccountNotification : public ::google::protobuf::Message { + public: + GameAccountNotification(); + virtual ~GameAccountNotification(); + + GameAccountNotification(const GameAccountNotification& from); + + inline GameAccountNotification& operator=(const GameAccountNotification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GameAccountNotification& default_instance(); + + void Swap(GameAccountNotification* other); + + // implements Message ---------------------------------------------- + + GameAccountNotification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GameAccountNotification& from); + void MergeFrom(const GameAccountNotification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.account.v1.GameAccountList game_accounts = 1; + inline int game_accounts_size() const; + inline void clear_game_accounts(); + static const int kGameAccountsFieldNumber = 1; + inline const ::bgs::protocol::account::v1::GameAccountList& game_accounts(int index) const; + inline ::bgs::protocol::account::v1::GameAccountList* mutable_game_accounts(int index); + inline ::bgs::protocol::account::v1::GameAccountList* add_game_accounts(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList >& + game_accounts() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList >* + mutable_game_accounts(); + + // optional uint64 subscriber_id = 2; + inline bool has_subscriber_id() const; + inline void clear_subscriber_id(); + static const int kSubscriberIdFieldNumber = 2; + inline ::google::protobuf::uint64 subscriber_id() const; + inline void set_subscriber_id(::google::protobuf::uint64 value); + + // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3; + inline bool has_account_tags() const; + inline void clear_account_tags(); + static const int kAccountTagsFieldNumber = 3; + inline const ::bgs::protocol::account::v1::AccountFieldTags& account_tags() const; + inline ::bgs::protocol::account::v1::AccountFieldTags* mutable_account_tags(); + inline ::bgs::protocol::account::v1::AccountFieldTags* release_account_tags(); + inline void set_allocated_account_tags(::bgs::protocol::account::v1::AccountFieldTags* account_tags); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountNotification) + private: + inline void set_has_subscriber_id(); + inline void clear_has_subscriber_id(); + inline void set_has_account_tags(); + inline void clear_has_account_tags(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList > game_accounts_; + ::google::protobuf::uint64 subscriber_id_; + ::bgs::protocol::account::v1::AccountFieldTags* account_tags_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GameAccountNotification* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GameAccountSessionNotification : public ::google::protobuf::Message { + public: + GameAccountSessionNotification(); + virtual ~GameAccountSessionNotification(); + + GameAccountSessionNotification(const GameAccountSessionNotification& from); + + inline GameAccountSessionNotification& operator=(const GameAccountSessionNotification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GameAccountSessionNotification& default_instance(); + + void Swap(GameAccountSessionNotification* other); + + // implements Message ---------------------------------------------- + + GameAccountSessionNotification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GameAccountSessionNotification& from); + void MergeFrom(const GameAccountSessionNotification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1; + inline bool has_game_account() const; + inline void clear_game_account(); + static const int kGameAccountFieldNumber = 1; + inline const ::bgs::protocol::account::v1::GameAccountHandle& game_account() const; + inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_game_account(); + inline ::bgs::protocol::account::v1::GameAccountHandle* release_game_account(); + inline void set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account); + + // optional .bgs.protocol.account.v1.GameSessionUpdateInfo session_info = 2; + inline bool has_session_info() const; + inline void clear_session_info(); + static const int kSessionInfoFieldNumber = 2; + inline const ::bgs::protocol::account::v1::GameSessionUpdateInfo& session_info() const; + inline ::bgs::protocol::account::v1::GameSessionUpdateInfo* mutable_session_info(); + inline ::bgs::protocol::account::v1::GameSessionUpdateInfo* release_session_info(); + inline void set_allocated_session_info(::bgs::protocol::account::v1::GameSessionUpdateInfo* session_info); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountSessionNotification) + private: + inline void set_has_game_account(); + inline void clear_has_game_account(); + inline void set_has_session_info(); + inline void clear_has_session_info(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::account::v1::GameAccountHandle* game_account_; + ::bgs::protocol::account::v1::GameSessionUpdateInfo* session_info_; + friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto(); + friend void protobuf_AssignDesc_account_5fservice_2eproto(); + friend void protobuf_ShutdownFile_account_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GameAccountSessionNotification* default_instance_; +}; +// =================================================================== + +class TC_SHARED_API AccountService : public ServiceBase +{ + public: + + template + explicit AccountService(HashSelector) : service_hash_(HashSelector::Result::value) { } + + typedef std::integral_constant OriginalHash; + typedef std::integral_constant NameHash; + + static google::protobuf::ServiceDescriptor const* descriptor(); + + // client methods -------------------------------------------------- + + void GetGameAccount(::bgs::protocol::account::v1::GameAccountHandle const* request, std::function responseCallback); + void GetAccount(::bgs::protocol::account::v1::GetAccountRequest const* request, std::function responseCallback); + void CreateGameAccount(::bgs::protocol::account::v1::CreateGameAccountRequest const* request, std::function responseCallback); + void IsIgrAddress(::bgs::protocol::account::v1::IsIgrAddressRequest const* request, std::function responseCallback); + void CacheExpire(::bgs::protocol::account::v1::CacheExpireRequest const* request); + void CredentialUpdate(::bgs::protocol::account::v1::CredentialUpdateRequest const* request, std::function responseCallback); + void Subscribe(::bgs::protocol::account::v1::SubscriptionUpdateRequest const* request, std::function responseCallback); + void Unsubscribe(::bgs::protocol::account::v1::SubscriptionUpdateRequest const* request, std::function responseCallback); + void GetAccountState(::bgs::protocol::account::v1::GetAccountStateRequest const* request, std::function responseCallback); + void GetGameAccountState(::bgs::protocol::account::v1::GetGameAccountStateRequest const* request, std::function responseCallback); + void GetLicenses(::bgs::protocol::account::v1::GetLicensesRequest const* request, std::function responseCallback); + void GetGameTimeRemainingInfo(::bgs::protocol::account::v1::GetGameTimeRemainingInfoRequest const* request, std::function responseCallback); + void GetGameSessionInfo(::bgs::protocol::account::v1::GetGameSessionInfoRequest const* request, std::function responseCallback); + void GetCAISInfo(::bgs::protocol::account::v1::GetCAISInfoRequest const* request, std::function responseCallback); + void ForwardCacheExpire(::bgs::protocol::account::v1::ForwardCacheExpireRequest const* request, std::function responseCallback); + void GetAuthorizedData(::bgs::protocol::account::v1::GetAuthorizedDataRequest const* request, std::function responseCallback); + void AccountFlagUpdate(::bgs::protocol::account::v1::AccountFlagUpdateRequest const* request); + void GameAccountFlagUpdate(::bgs::protocol::account::v1::GameAccountFlagUpdateRequest const* request); + // server methods -------------------------------------------------- + + void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final; + + protected: + virtual uint32 HandleGetGameAccount(::bgs::protocol::account::v1::GameAccountHandle const* request, ::bgs::protocol::account::v1::GameAccountBlob* response); + virtual uint32 HandleGetAccount(::bgs::protocol::account::v1::GetAccountRequest const* request, ::bgs::protocol::account::v1::GetAccountResponse* response); + virtual uint32 HandleCreateGameAccount(::bgs::protocol::account::v1::CreateGameAccountRequest const* request, ::bgs::protocol::account::v1::GameAccountHandle* response); + virtual uint32 HandleIsIgrAddress(::bgs::protocol::account::v1::IsIgrAddressRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleCacheExpire(::bgs::protocol::account::v1::CacheExpireRequest const* request); + virtual uint32 HandleCredentialUpdate(::bgs::protocol::account::v1::CredentialUpdateRequest const* request, ::bgs::protocol::account::v1::CredentialUpdateResponse* response); + virtual uint32 HandleSubscribe(::bgs::protocol::account::v1::SubscriptionUpdateRequest const* request, ::bgs::protocol::account::v1::SubscriptionUpdateResponse* response); + virtual uint32 HandleUnsubscribe(::bgs::protocol::account::v1::SubscriptionUpdateRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleGetAccountState(::bgs::protocol::account::v1::GetAccountStateRequest const* request, ::bgs::protocol::account::v1::GetAccountStateResponse* response); + virtual uint32 HandleGetGameAccountState(::bgs::protocol::account::v1::GetGameAccountStateRequest const* request, ::bgs::protocol::account::v1::GetGameAccountStateResponse* response); + virtual uint32 HandleGetLicenses(::bgs::protocol::account::v1::GetLicensesRequest const* request, ::bgs::protocol::account::v1::GetLicensesResponse* response); + virtual uint32 HandleGetGameTimeRemainingInfo(::bgs::protocol::account::v1::GetGameTimeRemainingInfoRequest const* request, ::bgs::protocol::account::v1::GetGameTimeRemainingInfoResponse* response); + virtual uint32 HandleGetGameSessionInfo(::bgs::protocol::account::v1::GetGameSessionInfoRequest const* request, ::bgs::protocol::account::v1::GetGameSessionInfoResponse* response); + virtual uint32 HandleGetCAISInfo(::bgs::protocol::account::v1::GetCAISInfoRequest const* request, ::bgs::protocol::account::v1::GetCAISInfoResponse* response); + virtual uint32 HandleForwardCacheExpire(::bgs::protocol::account::v1::ForwardCacheExpireRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleGetAuthorizedData(::bgs::protocol::account::v1::GetAuthorizedDataRequest const* request, ::bgs::protocol::account::v1::GetAuthorizedDataResponse* response); + virtual uint32 HandleAccountFlagUpdate(::bgs::protocol::account::v1::AccountFlagUpdateRequest const* request); + virtual uint32 HandleGameAccountFlagUpdate(::bgs::protocol::account::v1::GameAccountFlagUpdateRequest const* request); + + private: + uint32 service_hash_; + + GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(AccountService); +}; + +// ------------------------------------------------------------------- + +class TC_SHARED_API AccountListener : public ServiceBase +{ + public: + + template + explicit AccountListener(HashSelector) : service_hash_(HashSelector::Result::value) { } + + typedef std::integral_constant OriginalHash; + typedef std::integral_constant NameHash; + + static google::protobuf::ServiceDescriptor const* descriptor(); + + // client methods -------------------------------------------------- + + void OnAccountStateUpdated(::bgs::protocol::account::v1::AccountStateNotification const* request); + void OnGameAccountStateUpdated(::bgs::protocol::account::v1::GameAccountStateNotification const* request); + void OnGameAccountsUpdated(::bgs::protocol::account::v1::GameAccountNotification const* request); + void OnGameSessionUpdated(::bgs::protocol::account::v1::GameAccountSessionNotification const* request); + // server methods -------------------------------------------------- + + void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final; + + protected: + virtual uint32 HandleOnAccountStateUpdated(::bgs::protocol::account::v1::AccountStateNotification const* request); + virtual uint32 HandleOnGameAccountStateUpdated(::bgs::protocol::account::v1::GameAccountStateNotification const* request); + virtual uint32 HandleOnGameAccountsUpdated(::bgs::protocol::account::v1::GameAccountNotification const* request); + virtual uint32 HandleOnGameSessionUpdated(::bgs::protocol::account::v1::GameAccountSessionNotification const* request); + + private: + uint32 service_hash_; + + GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(AccountListener); +}; + +// =================================================================== + + +// =================================================================== + +// GetAccountRequest + +// optional .bgs.protocol.account.v1.AccountReference ref = 1; +inline bool GetAccountRequest::has_ref() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GetAccountRequest::set_has_ref() { + _has_bits_[0] |= 0x00000001u; +} +inline void GetAccountRequest::clear_has_ref() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GetAccountRequest::clear_ref() { + if (ref_ != NULL) ref_->::bgs::protocol::account::v1::AccountReference::Clear(); + clear_has_ref(); +} +inline const ::bgs::protocol::account::v1::AccountReference& GetAccountRequest::ref() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.ref) + return ref_ != NULL ? *ref_ : *default_instance_->ref_; +} +inline ::bgs::protocol::account::v1::AccountReference* GetAccountRequest::mutable_ref() { + set_has_ref(); + if (ref_ == NULL) ref_ = new ::bgs::protocol::account::v1::AccountReference; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountRequest.ref) + return ref_; +} +inline ::bgs::protocol::account::v1::AccountReference* GetAccountRequest::release_ref() { + clear_has_ref(); + ::bgs::protocol::account::v1::AccountReference* temp = ref_; + ref_ = NULL; + return temp; +} +inline void GetAccountRequest::set_allocated_ref(::bgs::protocol::account::v1::AccountReference* ref) { + delete ref_; + ref_ = ref; + if (ref) { + set_has_ref(); + } else { + clear_has_ref(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountRequest.ref) +} + +// optional bool fetch_all = 10 [default = false]; +inline bool GetAccountRequest::has_fetch_all() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GetAccountRequest::set_has_fetch_all() { + _has_bits_[0] |= 0x00000002u; +} +inline void GetAccountRequest::clear_has_fetch_all() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GetAccountRequest::clear_fetch_all() { + fetch_all_ = false; + clear_has_fetch_all(); +} +inline bool GetAccountRequest::fetch_all() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_all) + return fetch_all_; +} +inline void GetAccountRequest::set_fetch_all(bool value) { + set_has_fetch_all(); + fetch_all_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_all) +} + +// optional bool fetch_blob = 11 [default = false]; +inline bool GetAccountRequest::has_fetch_blob() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GetAccountRequest::set_has_fetch_blob() { + _has_bits_[0] |= 0x00000004u; +} +inline void GetAccountRequest::clear_has_fetch_blob() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GetAccountRequest::clear_fetch_blob() { + fetch_blob_ = false; + clear_has_fetch_blob(); +} +inline bool GetAccountRequest::fetch_blob() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_blob) + return fetch_blob_; +} +inline void GetAccountRequest::set_fetch_blob(bool value) { + set_has_fetch_blob(); + fetch_blob_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_blob) +} + +// optional bool fetch_id = 12 [default = false]; +inline bool GetAccountRequest::has_fetch_id() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void GetAccountRequest::set_has_fetch_id() { + _has_bits_[0] |= 0x00000008u; +} +inline void GetAccountRequest::clear_has_fetch_id() { + _has_bits_[0] &= ~0x00000008u; +} +inline void GetAccountRequest::clear_fetch_id() { + fetch_id_ = false; + clear_has_fetch_id(); +} +inline bool GetAccountRequest::fetch_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_id) + return fetch_id_; +} +inline void GetAccountRequest::set_fetch_id(bool value) { + set_has_fetch_id(); + fetch_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_id) +} + +// optional bool fetch_email = 13 [default = false]; +inline bool GetAccountRequest::has_fetch_email() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void GetAccountRequest::set_has_fetch_email() { + _has_bits_[0] |= 0x00000010u; +} +inline void GetAccountRequest::clear_has_fetch_email() { + _has_bits_[0] &= ~0x00000010u; +} +inline void GetAccountRequest::clear_fetch_email() { + fetch_email_ = false; + clear_has_fetch_email(); +} +inline bool GetAccountRequest::fetch_email() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_email) + return fetch_email_; +} +inline void GetAccountRequest::set_fetch_email(bool value) { + set_has_fetch_email(); + fetch_email_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_email) +} + +// optional bool fetch_battle_tag = 14 [default = false]; +inline bool GetAccountRequest::has_fetch_battle_tag() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void GetAccountRequest::set_has_fetch_battle_tag() { + _has_bits_[0] |= 0x00000020u; +} +inline void GetAccountRequest::clear_has_fetch_battle_tag() { + _has_bits_[0] &= ~0x00000020u; +} +inline void GetAccountRequest::clear_fetch_battle_tag() { + fetch_battle_tag_ = false; + clear_has_fetch_battle_tag(); +} +inline bool GetAccountRequest::fetch_battle_tag() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_battle_tag) + return fetch_battle_tag_; +} +inline void GetAccountRequest::set_fetch_battle_tag(bool value) { + set_has_fetch_battle_tag(); + fetch_battle_tag_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_battle_tag) +} + +// optional bool fetch_full_name = 15 [default = false]; +inline bool GetAccountRequest::has_fetch_full_name() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void GetAccountRequest::set_has_fetch_full_name() { + _has_bits_[0] |= 0x00000040u; +} +inline void GetAccountRequest::clear_has_fetch_full_name() { + _has_bits_[0] &= ~0x00000040u; +} +inline void GetAccountRequest::clear_fetch_full_name() { + fetch_full_name_ = false; + clear_has_fetch_full_name(); +} +inline bool GetAccountRequest::fetch_full_name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_full_name) + return fetch_full_name_; +} +inline void GetAccountRequest::set_fetch_full_name(bool value) { + set_has_fetch_full_name(); + fetch_full_name_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_full_name) +} + +// optional bool fetch_links = 16 [default = false]; +inline bool GetAccountRequest::has_fetch_links() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void GetAccountRequest::set_has_fetch_links() { + _has_bits_[0] |= 0x00000080u; +} +inline void GetAccountRequest::clear_has_fetch_links() { + _has_bits_[0] &= ~0x00000080u; +} +inline void GetAccountRequest::clear_fetch_links() { + fetch_links_ = false; + clear_has_fetch_links(); +} +inline bool GetAccountRequest::fetch_links() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_links) + return fetch_links_; +} +inline void GetAccountRequest::set_fetch_links(bool value) { + set_has_fetch_links(); + fetch_links_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_links) +} + +// optional bool fetch_parental_controls = 17 [default = false]; +inline bool GetAccountRequest::has_fetch_parental_controls() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void GetAccountRequest::set_has_fetch_parental_controls() { + _has_bits_[0] |= 0x00000100u; +} +inline void GetAccountRequest::clear_has_fetch_parental_controls() { + _has_bits_[0] &= ~0x00000100u; +} +inline void GetAccountRequest::clear_fetch_parental_controls() { + fetch_parental_controls_ = false; + clear_has_fetch_parental_controls(); +} +inline bool GetAccountRequest::fetch_parental_controls() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_parental_controls) + return fetch_parental_controls_; +} +inline void GetAccountRequest::set_fetch_parental_controls(bool value) { + set_has_fetch_parental_controls(); + fetch_parental_controls_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_parental_controls) +} + +// ------------------------------------------------------------------- + +// GetAccountResponse + +// optional .bgs.protocol.account.v1.AccountBlob blob = 11; +inline bool GetAccountResponse::has_blob() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GetAccountResponse::set_has_blob() { + _has_bits_[0] |= 0x00000001u; +} +inline void GetAccountResponse::clear_has_blob() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GetAccountResponse::clear_blob() { + if (blob_ != NULL) blob_->::bgs::protocol::account::v1::AccountBlob::Clear(); + clear_has_blob(); +} +inline const ::bgs::protocol::account::v1::AccountBlob& GetAccountResponse::blob() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountResponse.blob) + return blob_ != NULL ? *blob_ : *default_instance_->blob_; +} +inline ::bgs::protocol::account::v1::AccountBlob* GetAccountResponse::mutable_blob() { + set_has_blob(); + if (blob_ == NULL) blob_ = new ::bgs::protocol::account::v1::AccountBlob; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountResponse.blob) + return blob_; +} +inline ::bgs::protocol::account::v1::AccountBlob* GetAccountResponse::release_blob() { + clear_has_blob(); + ::bgs::protocol::account::v1::AccountBlob* temp = blob_; + blob_ = NULL; + return temp; +} +inline void GetAccountResponse::set_allocated_blob(::bgs::protocol::account::v1::AccountBlob* blob) { + delete blob_; + blob_ = blob; + if (blob) { + set_has_blob(); + } else { + clear_has_blob(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountResponse.blob) +} + +// optional .bgs.protocol.account.v1.AccountId id = 12; +inline bool GetAccountResponse::has_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GetAccountResponse::set_has_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void GetAccountResponse::clear_has_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GetAccountResponse::clear_id() { + if (id_ != NULL) id_->::bgs::protocol::account::v1::AccountId::Clear(); + clear_has_id(); +} +inline const ::bgs::protocol::account::v1::AccountId& GetAccountResponse::id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountResponse.id) + return id_ != NULL ? *id_ : *default_instance_->id_; +} +inline ::bgs::protocol::account::v1::AccountId* GetAccountResponse::mutable_id() { + set_has_id(); + if (id_ == NULL) id_ = new ::bgs::protocol::account::v1::AccountId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountResponse.id) + return id_; +} +inline ::bgs::protocol::account::v1::AccountId* GetAccountResponse::release_id() { + clear_has_id(); + ::bgs::protocol::account::v1::AccountId* temp = id_; + id_ = NULL; + return temp; +} +inline void GetAccountResponse::set_allocated_id(::bgs::protocol::account::v1::AccountId* id) { + delete id_; + id_ = id; + if (id) { + set_has_id(); + } else { + clear_has_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountResponse.id) +} + +// repeated string email = 13; +inline int GetAccountResponse::email_size() const { + return email_.size(); +} +inline void GetAccountResponse::clear_email() { + email_.Clear(); +} +inline const ::std::string& GetAccountResponse::email(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountResponse.email) + return email_.Get(index); +} +inline ::std::string* GetAccountResponse::mutable_email(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountResponse.email) + return email_.Mutable(index); +} +inline void GetAccountResponse::set_email(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountResponse.email) + email_.Mutable(index)->assign(value); +} +inline void GetAccountResponse::set_email(int index, const char* value) { + email_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GetAccountResponse.email) +} +inline void GetAccountResponse::set_email(int index, const char* value, size_t size) { + email_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GetAccountResponse.email) +} +inline ::std::string* GetAccountResponse::add_email() { + return email_.Add(); +} +inline void GetAccountResponse::add_email(const ::std::string& value) { + email_.Add()->assign(value); + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GetAccountResponse.email) +} +inline void GetAccountResponse::add_email(const char* value) { + email_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:bgs.protocol.account.v1.GetAccountResponse.email) +} +inline void GetAccountResponse::add_email(const char* value, size_t size) { + email_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:bgs.protocol.account.v1.GetAccountResponse.email) +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +GetAccountResponse::email() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GetAccountResponse.email) + return email_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +GetAccountResponse::mutable_email() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GetAccountResponse.email) + return &email_; +} + +// optional string battle_tag = 14; +inline bool GetAccountResponse::has_battle_tag() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void GetAccountResponse::set_has_battle_tag() { + _has_bits_[0] |= 0x00000008u; +} +inline void GetAccountResponse::clear_has_battle_tag() { + _has_bits_[0] &= ~0x00000008u; +} +inline void GetAccountResponse::clear_battle_tag() { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_->clear(); + } + clear_has_battle_tag(); +} +inline const ::std::string& GetAccountResponse::battle_tag() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountResponse.battle_tag) + return *battle_tag_; +} +inline void GetAccountResponse::set_battle_tag(const ::std::string& value) { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + battle_tag_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountResponse.battle_tag) +} +inline void GetAccountResponse::set_battle_tag(const char* value) { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + battle_tag_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GetAccountResponse.battle_tag) +} +inline void GetAccountResponse::set_battle_tag(const char* value, size_t size) { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + battle_tag_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GetAccountResponse.battle_tag) +} +inline ::std::string* GetAccountResponse::mutable_battle_tag() { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountResponse.battle_tag) + return battle_tag_; +} +inline ::std::string* GetAccountResponse::release_battle_tag() { + clear_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = battle_tag_; + battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void GetAccountResponse::set_allocated_battle_tag(::std::string* battle_tag) { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete battle_tag_; + } + if (battle_tag) { + set_has_battle_tag(); + battle_tag_ = battle_tag; + } else { + clear_has_battle_tag(); + battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountResponse.battle_tag) +} + +// optional string full_name = 15; +inline bool GetAccountResponse::has_full_name() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void GetAccountResponse::set_has_full_name() { + _has_bits_[0] |= 0x00000010u; +} +inline void GetAccountResponse::clear_has_full_name() { + _has_bits_[0] &= ~0x00000010u; +} +inline void GetAccountResponse::clear_full_name() { + if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + full_name_->clear(); + } + clear_has_full_name(); +} +inline const ::std::string& GetAccountResponse::full_name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountResponse.full_name) + return *full_name_; +} +inline void GetAccountResponse::set_full_name(const ::std::string& value) { + set_has_full_name(); + if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + full_name_ = new ::std::string; + } + full_name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountResponse.full_name) +} +inline void GetAccountResponse::set_full_name(const char* value) { + set_has_full_name(); + if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + full_name_ = new ::std::string; + } + full_name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GetAccountResponse.full_name) +} +inline void GetAccountResponse::set_full_name(const char* value, size_t size) { + set_has_full_name(); + if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + full_name_ = new ::std::string; + } + full_name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GetAccountResponse.full_name) +} +inline ::std::string* GetAccountResponse::mutable_full_name() { + set_has_full_name(); + if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + full_name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountResponse.full_name) + return full_name_; +} +inline ::std::string* GetAccountResponse::release_full_name() { + clear_has_full_name(); + if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = full_name_; + full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void GetAccountResponse::set_allocated_full_name(::std::string* full_name) { + if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete full_name_; + } + if (full_name) { + set_has_full_name(); + full_name_ = full_name; + } else { + clear_has_full_name(); + full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountResponse.full_name) +} + +// repeated .bgs.protocol.account.v1.GameAccountLink links = 16; +inline int GetAccountResponse::links_size() const { + return links_.size(); +} +inline void GetAccountResponse::clear_links() { + links_.Clear(); +} +inline const ::bgs::protocol::account::v1::GameAccountLink& GetAccountResponse::links(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountResponse.links) + return links_.Get(index); +} +inline ::bgs::protocol::account::v1::GameAccountLink* GetAccountResponse::mutable_links(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountResponse.links) + return links_.Mutable(index); +} +inline ::bgs::protocol::account::v1::GameAccountLink* GetAccountResponse::add_links() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GetAccountResponse.links) + return links_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink >& +GetAccountResponse::links() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GetAccountResponse.links) + return links_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink >* +GetAccountResponse::mutable_links() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GetAccountResponse.links) + return &links_; +} + +// optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 17; +inline bool GetAccountResponse::has_parental_control_info() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void GetAccountResponse::set_has_parental_control_info() { + _has_bits_[0] |= 0x00000040u; +} +inline void GetAccountResponse::clear_has_parental_control_info() { + _has_bits_[0] &= ~0x00000040u; +} +inline void GetAccountResponse::clear_parental_control_info() { + if (parental_control_info_ != NULL) parental_control_info_->::bgs::protocol::account::v1::ParentalControlInfo::Clear(); + clear_has_parental_control_info(); +} +inline const ::bgs::protocol::account::v1::ParentalControlInfo& GetAccountResponse::parental_control_info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountResponse.parental_control_info) + return parental_control_info_ != NULL ? *parental_control_info_ : *default_instance_->parental_control_info_; +} +inline ::bgs::protocol::account::v1::ParentalControlInfo* GetAccountResponse::mutable_parental_control_info() { + set_has_parental_control_info(); + if (parental_control_info_ == NULL) parental_control_info_ = new ::bgs::protocol::account::v1::ParentalControlInfo; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountResponse.parental_control_info) + return parental_control_info_; +} +inline ::bgs::protocol::account::v1::ParentalControlInfo* GetAccountResponse::release_parental_control_info() { + clear_has_parental_control_info(); + ::bgs::protocol::account::v1::ParentalControlInfo* temp = parental_control_info_; + parental_control_info_ = NULL; + return temp; +} +inline void GetAccountResponse::set_allocated_parental_control_info(::bgs::protocol::account::v1::ParentalControlInfo* parental_control_info) { + delete parental_control_info_; + parental_control_info_ = parental_control_info; + if (parental_control_info) { + set_has_parental_control_info(); + } else { + clear_has_parental_control_info(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountResponse.parental_control_info) +} + +// ------------------------------------------------------------------- + +// CreateGameAccountRequest + +// optional .bgs.protocol.account.v1.AccountId account = 1; +inline bool CreateGameAccountRequest::has_account() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void CreateGameAccountRequest::set_has_account() { + _has_bits_[0] |= 0x00000001u; +} +inline void CreateGameAccountRequest::clear_has_account() { + _has_bits_[0] &= ~0x00000001u; +} +inline void CreateGameAccountRequest::clear_account() { + if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear(); + clear_has_account(); +} +inline const ::bgs::protocol::account::v1::AccountId& CreateGameAccountRequest::account() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CreateGameAccountRequest.account) + return account_ != NULL ? *account_ : *default_instance_->account_; +} +inline ::bgs::protocol::account::v1::AccountId* CreateGameAccountRequest::mutable_account() { + set_has_account(); + if (account_ == NULL) account_ = new ::bgs::protocol::account::v1::AccountId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.CreateGameAccountRequest.account) + return account_; +} +inline ::bgs::protocol::account::v1::AccountId* CreateGameAccountRequest::release_account() { + clear_has_account(); + ::bgs::protocol::account::v1::AccountId* temp = account_; + account_ = NULL; + return temp; +} +inline void CreateGameAccountRequest::set_allocated_account(::bgs::protocol::account::v1::AccountId* account) { + delete account_; + account_ = account; + if (account) { + set_has_account(); + } else { + clear_has_account(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.CreateGameAccountRequest.account) +} + +// optional uint32 region = 2; +inline bool CreateGameAccountRequest::has_region() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void CreateGameAccountRequest::set_has_region() { + _has_bits_[0] |= 0x00000002u; +} +inline void CreateGameAccountRequest::clear_has_region() { + _has_bits_[0] &= ~0x00000002u; +} +inline void CreateGameAccountRequest::clear_region() { + region_ = 0u; + clear_has_region(); +} +inline ::google::protobuf::uint32 CreateGameAccountRequest::region() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CreateGameAccountRequest.region) + return region_; +} +inline void CreateGameAccountRequest::set_region(::google::protobuf::uint32 value) { + set_has_region(); + region_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.CreateGameAccountRequest.region) +} + +// optional fixed32 program = 3; +inline bool CreateGameAccountRequest::has_program() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void CreateGameAccountRequest::set_has_program() { + _has_bits_[0] |= 0x00000004u; +} +inline void CreateGameAccountRequest::clear_has_program() { + _has_bits_[0] &= ~0x00000004u; +} +inline void CreateGameAccountRequest::clear_program() { + program_ = 0u; + clear_has_program(); +} +inline ::google::protobuf::uint32 CreateGameAccountRequest::program() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CreateGameAccountRequest.program) + return program_; +} +inline void CreateGameAccountRequest::set_program(::google::protobuf::uint32 value) { + set_has_program(); + program_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.CreateGameAccountRequest.program) +} + +// optional uint32 realm_permissions = 4 [default = 1]; +inline bool CreateGameAccountRequest::has_realm_permissions() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void CreateGameAccountRequest::set_has_realm_permissions() { + _has_bits_[0] |= 0x00000008u; +} +inline void CreateGameAccountRequest::clear_has_realm_permissions() { + _has_bits_[0] &= ~0x00000008u; +} +inline void CreateGameAccountRequest::clear_realm_permissions() { + realm_permissions_ = 1u; + clear_has_realm_permissions(); +} +inline ::google::protobuf::uint32 CreateGameAccountRequest::realm_permissions() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CreateGameAccountRequest.realm_permissions) + return realm_permissions_; +} +inline void CreateGameAccountRequest::set_realm_permissions(::google::protobuf::uint32 value) { + set_has_realm_permissions(); + realm_permissions_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.CreateGameAccountRequest.realm_permissions) +} + +// ------------------------------------------------------------------- + +// CacheExpireRequest + +// repeated .bgs.protocol.account.v1.AccountId account = 1; +inline int CacheExpireRequest::account_size() const { + return account_.size(); +} +inline void CacheExpireRequest::clear_account() { + account_.Clear(); +} +inline const ::bgs::protocol::account::v1::AccountId& CacheExpireRequest::account(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CacheExpireRequest.account) + return account_.Get(index); +} +inline ::bgs::protocol::account::v1::AccountId* CacheExpireRequest::mutable_account(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.CacheExpireRequest.account) + return account_.Mutable(index); +} +inline ::bgs::protocol::account::v1::AccountId* CacheExpireRequest::add_account() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.CacheExpireRequest.account) + return account_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountId >& +CacheExpireRequest::account() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.CacheExpireRequest.account) + return account_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountId >* +CacheExpireRequest::mutable_account() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.CacheExpireRequest.account) + return &account_; +} + +// repeated .bgs.protocol.account.v1.GameAccountHandle game_account = 2; +inline int CacheExpireRequest::game_account_size() const { + return game_account_.size(); +} +inline void CacheExpireRequest::clear_game_account() { + game_account_.Clear(); +} +inline const ::bgs::protocol::account::v1::GameAccountHandle& CacheExpireRequest::game_account(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CacheExpireRequest.game_account) + return game_account_.Get(index); +} +inline ::bgs::protocol::account::v1::GameAccountHandle* CacheExpireRequest::mutable_game_account(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.CacheExpireRequest.game_account) + return game_account_.Mutable(index); +} +inline ::bgs::protocol::account::v1::GameAccountHandle* CacheExpireRequest::add_game_account() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.CacheExpireRequest.game_account) + return game_account_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle >& +CacheExpireRequest::game_account() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.CacheExpireRequest.game_account) + return game_account_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle >* +CacheExpireRequest::mutable_game_account() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.CacheExpireRequest.game_account) + return &game_account_; +} + +// repeated string email = 3; +inline int CacheExpireRequest::email_size() const { + return email_.size(); +} +inline void CacheExpireRequest::clear_email() { + email_.Clear(); +} +inline const ::std::string& CacheExpireRequest::email(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CacheExpireRequest.email) + return email_.Get(index); +} +inline ::std::string* CacheExpireRequest::mutable_email(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.CacheExpireRequest.email) + return email_.Mutable(index); +} +inline void CacheExpireRequest::set_email(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.CacheExpireRequest.email) + email_.Mutable(index)->assign(value); +} +inline void CacheExpireRequest::set_email(int index, const char* value) { + email_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.CacheExpireRequest.email) +} +inline void CacheExpireRequest::set_email(int index, const char* value, size_t size) { + email_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.CacheExpireRequest.email) +} +inline ::std::string* CacheExpireRequest::add_email() { + return email_.Add(); +} +inline void CacheExpireRequest::add_email(const ::std::string& value) { + email_.Add()->assign(value); + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.CacheExpireRequest.email) +} +inline void CacheExpireRequest::add_email(const char* value) { + email_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:bgs.protocol.account.v1.CacheExpireRequest.email) +} +inline void CacheExpireRequest::add_email(const char* value, size_t size) { + email_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:bgs.protocol.account.v1.CacheExpireRequest.email) +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +CacheExpireRequest::email() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.CacheExpireRequest.email) + return email_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +CacheExpireRequest::mutable_email() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.CacheExpireRequest.email) + return &email_; +} + +// ------------------------------------------------------------------- + +// CredentialUpdateRequest + +// required .bgs.protocol.account.v1.AccountId account = 1; +inline bool CredentialUpdateRequest::has_account() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void CredentialUpdateRequest::set_has_account() { + _has_bits_[0] |= 0x00000001u; +} +inline void CredentialUpdateRequest::clear_has_account() { + _has_bits_[0] &= ~0x00000001u; +} +inline void CredentialUpdateRequest::clear_account() { + if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear(); + clear_has_account(); +} +inline const ::bgs::protocol::account::v1::AccountId& CredentialUpdateRequest::account() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CredentialUpdateRequest.account) + return account_ != NULL ? *account_ : *default_instance_->account_; +} +inline ::bgs::protocol::account::v1::AccountId* CredentialUpdateRequest::mutable_account() { + set_has_account(); + if (account_ == NULL) account_ = new ::bgs::protocol::account::v1::AccountId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.CredentialUpdateRequest.account) + return account_; +} +inline ::bgs::protocol::account::v1::AccountId* CredentialUpdateRequest::release_account() { + clear_has_account(); + ::bgs::protocol::account::v1::AccountId* temp = account_; + account_ = NULL; + return temp; +} +inline void CredentialUpdateRequest::set_allocated_account(::bgs::protocol::account::v1::AccountId* account) { + delete account_; + account_ = account; + if (account) { + set_has_account(); + } else { + clear_has_account(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.CredentialUpdateRequest.account) +} + +// repeated .bgs.protocol.account.v1.AccountCredential old_credentials = 2; +inline int CredentialUpdateRequest::old_credentials_size() const { + return old_credentials_.size(); +} +inline void CredentialUpdateRequest::clear_old_credentials() { + old_credentials_.Clear(); +} +inline const ::bgs::protocol::account::v1::AccountCredential& CredentialUpdateRequest::old_credentials(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CredentialUpdateRequest.old_credentials) + return old_credentials_.Get(index); +} +inline ::bgs::protocol::account::v1::AccountCredential* CredentialUpdateRequest::mutable_old_credentials(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.CredentialUpdateRequest.old_credentials) + return old_credentials_.Mutable(index); +} +inline ::bgs::protocol::account::v1::AccountCredential* CredentialUpdateRequest::add_old_credentials() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.CredentialUpdateRequest.old_credentials) + return old_credentials_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >& +CredentialUpdateRequest::old_credentials() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.CredentialUpdateRequest.old_credentials) + return old_credentials_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >* +CredentialUpdateRequest::mutable_old_credentials() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.CredentialUpdateRequest.old_credentials) + return &old_credentials_; +} + +// repeated .bgs.protocol.account.v1.AccountCredential new_credentials = 3; +inline int CredentialUpdateRequest::new_credentials_size() const { + return new_credentials_.size(); +} +inline void CredentialUpdateRequest::clear_new_credentials() { + new_credentials_.Clear(); +} +inline const ::bgs::protocol::account::v1::AccountCredential& CredentialUpdateRequest::new_credentials(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CredentialUpdateRequest.new_credentials) + return new_credentials_.Get(index); +} +inline ::bgs::protocol::account::v1::AccountCredential* CredentialUpdateRequest::mutable_new_credentials(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.CredentialUpdateRequest.new_credentials) + return new_credentials_.Mutable(index); +} +inline ::bgs::protocol::account::v1::AccountCredential* CredentialUpdateRequest::add_new_credentials() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.CredentialUpdateRequest.new_credentials) + return new_credentials_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >& +CredentialUpdateRequest::new_credentials() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.CredentialUpdateRequest.new_credentials) + return new_credentials_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >* +CredentialUpdateRequest::mutable_new_credentials() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.CredentialUpdateRequest.new_credentials) + return &new_credentials_; +} + +// optional uint32 region = 4; +inline bool CredentialUpdateRequest::has_region() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void CredentialUpdateRequest::set_has_region() { + _has_bits_[0] |= 0x00000008u; +} +inline void CredentialUpdateRequest::clear_has_region() { + _has_bits_[0] &= ~0x00000008u; +} +inline void CredentialUpdateRequest::clear_region() { + region_ = 0u; + clear_has_region(); +} +inline ::google::protobuf::uint32 CredentialUpdateRequest::region() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CredentialUpdateRequest.region) + return region_; +} +inline void CredentialUpdateRequest::set_region(::google::protobuf::uint32 value) { + set_has_region(); + region_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.CredentialUpdateRequest.region) +} + +// ------------------------------------------------------------------- + +// CredentialUpdateResponse + +// ------------------------------------------------------------------- + +// AccountFlagUpdateRequest + +// optional .bgs.protocol.account.v1.AccountId account = 1; +inline bool AccountFlagUpdateRequest::has_account() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AccountFlagUpdateRequest::set_has_account() { + _has_bits_[0] |= 0x00000001u; +} +inline void AccountFlagUpdateRequest::clear_has_account() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AccountFlagUpdateRequest::clear_account() { + if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear(); + clear_has_account(); +} +inline const ::bgs::protocol::account::v1::AccountId& AccountFlagUpdateRequest::account() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFlagUpdateRequest.account) + return account_ != NULL ? *account_ : *default_instance_->account_; +} +inline ::bgs::protocol::account::v1::AccountId* AccountFlagUpdateRequest::mutable_account() { + set_has_account(); + if (account_ == NULL) account_ = new ::bgs::protocol::account::v1::AccountId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountFlagUpdateRequest.account) + return account_; +} +inline ::bgs::protocol::account::v1::AccountId* AccountFlagUpdateRequest::release_account() { + clear_has_account(); + ::bgs::protocol::account::v1::AccountId* temp = account_; + account_ = NULL; + return temp; +} +inline void AccountFlagUpdateRequest::set_allocated_account(::bgs::protocol::account::v1::AccountId* account) { + delete account_; + account_ = account; + if (account) { + set_has_account(); + } else { + clear_has_account(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountFlagUpdateRequest.account) +} + +// optional uint32 region = 2; +inline bool AccountFlagUpdateRequest::has_region() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void AccountFlagUpdateRequest::set_has_region() { + _has_bits_[0] |= 0x00000002u; +} +inline void AccountFlagUpdateRequest::clear_has_region() { + _has_bits_[0] &= ~0x00000002u; +} +inline void AccountFlagUpdateRequest::clear_region() { + region_ = 0u; + clear_has_region(); +} +inline ::google::protobuf::uint32 AccountFlagUpdateRequest::region() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFlagUpdateRequest.region) + return region_; +} +inline void AccountFlagUpdateRequest::set_region(::google::protobuf::uint32 value) { + set_has_region(); + region_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFlagUpdateRequest.region) +} + +// optional uint64 flag = 3; +inline bool AccountFlagUpdateRequest::has_flag() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void AccountFlagUpdateRequest::set_has_flag() { + _has_bits_[0] |= 0x00000004u; +} +inline void AccountFlagUpdateRequest::clear_has_flag() { + _has_bits_[0] &= ~0x00000004u; +} +inline void AccountFlagUpdateRequest::clear_flag() { + flag_ = GOOGLE_ULONGLONG(0); + clear_has_flag(); +} +inline ::google::protobuf::uint64 AccountFlagUpdateRequest::flag() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFlagUpdateRequest.flag) + return flag_; +} +inline void AccountFlagUpdateRequest::set_flag(::google::protobuf::uint64 value) { + set_has_flag(); + flag_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFlagUpdateRequest.flag) +} + +// optional bool active = 4; +inline bool AccountFlagUpdateRequest::has_active() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void AccountFlagUpdateRequest::set_has_active() { + _has_bits_[0] |= 0x00000008u; +} +inline void AccountFlagUpdateRequest::clear_has_active() { + _has_bits_[0] &= ~0x00000008u; +} +inline void AccountFlagUpdateRequest::clear_active() { + active_ = false; + clear_has_active(); +} +inline bool AccountFlagUpdateRequest::active() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFlagUpdateRequest.active) + return active_; +} +inline void AccountFlagUpdateRequest::set_active(bool value) { + set_has_active(); + active_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFlagUpdateRequest.active) +} + +// ------------------------------------------------------------------- + +// GameAccountFlagUpdateRequest + +// optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1; +inline bool GameAccountFlagUpdateRequest::has_game_account() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GameAccountFlagUpdateRequest::set_has_game_account() { + _has_bits_[0] |= 0x00000001u; +} +inline void GameAccountFlagUpdateRequest::clear_has_game_account() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GameAccountFlagUpdateRequest::clear_game_account() { + if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear(); + clear_has_game_account(); +} +inline const ::bgs::protocol::account::v1::GameAccountHandle& GameAccountFlagUpdateRequest::game_account() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFlagUpdateRequest.game_account) + return game_account_ != NULL ? *game_account_ : *default_instance_->game_account_; +} +inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountFlagUpdateRequest::mutable_game_account() { + set_has_game_account(); + if (game_account_ == NULL) game_account_ = new ::bgs::protocol::account::v1::GameAccountHandle; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountFlagUpdateRequest.game_account) + return game_account_; +} +inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountFlagUpdateRequest::release_game_account() { + clear_has_game_account(); + ::bgs::protocol::account::v1::GameAccountHandle* temp = game_account_; + game_account_ = NULL; + return temp; +} +inline void GameAccountFlagUpdateRequest::set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account) { + delete game_account_; + game_account_ = game_account; + if (game_account) { + set_has_game_account(); + } else { + clear_has_game_account(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountFlagUpdateRequest.game_account) +} + +// optional uint64 flag = 2; +inline bool GameAccountFlagUpdateRequest::has_flag() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GameAccountFlagUpdateRequest::set_has_flag() { + _has_bits_[0] |= 0x00000002u; +} +inline void GameAccountFlagUpdateRequest::clear_has_flag() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GameAccountFlagUpdateRequest::clear_flag() { + flag_ = GOOGLE_ULONGLONG(0); + clear_has_flag(); +} +inline ::google::protobuf::uint64 GameAccountFlagUpdateRequest::flag() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFlagUpdateRequest.flag) + return flag_; +} +inline void GameAccountFlagUpdateRequest::set_flag(::google::protobuf::uint64 value) { + set_has_flag(); + flag_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountFlagUpdateRequest.flag) +} + +// optional bool active = 3; +inline bool GameAccountFlagUpdateRequest::has_active() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GameAccountFlagUpdateRequest::set_has_active() { + _has_bits_[0] |= 0x00000004u; +} +inline void GameAccountFlagUpdateRequest::clear_has_active() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GameAccountFlagUpdateRequest::clear_active() { + active_ = false; + clear_has_active(); +} +inline bool GameAccountFlagUpdateRequest::active() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFlagUpdateRequest.active) + return active_; +} +inline void GameAccountFlagUpdateRequest::set_active(bool value) { + set_has_active(); + active_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountFlagUpdateRequest.active) +} + +// ------------------------------------------------------------------- + +// SubscriptionUpdateRequest + +// repeated .bgs.protocol.account.v1.SubscriberReference ref = 2; +inline int SubscriptionUpdateRequest::ref_size() const { + return ref_.size(); +} +inline void SubscriptionUpdateRequest::clear_ref() { + ref_.Clear(); +} +inline const ::bgs::protocol::account::v1::SubscriberReference& SubscriptionUpdateRequest::ref(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SubscriptionUpdateRequest.ref) + return ref_.Get(index); +} +inline ::bgs::protocol::account::v1::SubscriberReference* SubscriptionUpdateRequest::mutable_ref(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.SubscriptionUpdateRequest.ref) + return ref_.Mutable(index); +} +inline ::bgs::protocol::account::v1::SubscriberReference* SubscriptionUpdateRequest::add_ref() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.SubscriptionUpdateRequest.ref) + return ref_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference >& +SubscriptionUpdateRequest::ref() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.SubscriptionUpdateRequest.ref) + return ref_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference >* +SubscriptionUpdateRequest::mutable_ref() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.SubscriptionUpdateRequest.ref) + return &ref_; +} + +// ------------------------------------------------------------------- + +// SubscriptionUpdateResponse + +// repeated .bgs.protocol.account.v1.SubscriberReference ref = 1; +inline int SubscriptionUpdateResponse::ref_size() const { + return ref_.size(); +} +inline void SubscriptionUpdateResponse::clear_ref() { + ref_.Clear(); +} +inline const ::bgs::protocol::account::v1::SubscriberReference& SubscriptionUpdateResponse::ref(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SubscriptionUpdateResponse.ref) + return ref_.Get(index); +} +inline ::bgs::protocol::account::v1::SubscriberReference* SubscriptionUpdateResponse::mutable_ref(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.SubscriptionUpdateResponse.ref) + return ref_.Mutable(index); +} +inline ::bgs::protocol::account::v1::SubscriberReference* SubscriptionUpdateResponse::add_ref() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.SubscriptionUpdateResponse.ref) + return ref_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference >& +SubscriptionUpdateResponse::ref() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.SubscriptionUpdateResponse.ref) + return ref_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference >* +SubscriptionUpdateResponse::mutable_ref() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.SubscriptionUpdateResponse.ref) + return &ref_; +} + +// ------------------------------------------------------------------- + +// IsIgrAddressRequest + +// optional string client_address = 1; +inline bool IsIgrAddressRequest::has_client_address() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void IsIgrAddressRequest::set_has_client_address() { + _has_bits_[0] |= 0x00000001u; +} +inline void IsIgrAddressRequest::clear_has_client_address() { + _has_bits_[0] &= ~0x00000001u; +} +inline void IsIgrAddressRequest::clear_client_address() { + if (client_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_address_->clear(); + } + clear_has_client_address(); +} +inline const ::std::string& IsIgrAddressRequest::client_address() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.IsIgrAddressRequest.client_address) + return *client_address_; +} +inline void IsIgrAddressRequest::set_client_address(const ::std::string& value) { + set_has_client_address(); + if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_address_ = new ::std::string; + } + client_address_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.IsIgrAddressRequest.client_address) +} +inline void IsIgrAddressRequest::set_client_address(const char* value) { + set_has_client_address(); + if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_address_ = new ::std::string; + } + client_address_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.IsIgrAddressRequest.client_address) +} +inline void IsIgrAddressRequest::set_client_address(const char* value, size_t size) { + set_has_client_address(); + if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_address_ = new ::std::string; + } + client_address_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.IsIgrAddressRequest.client_address) +} +inline ::std::string* IsIgrAddressRequest::mutable_client_address() { + set_has_client_address(); + if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_address_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.IsIgrAddressRequest.client_address) + return client_address_; +} +inline ::std::string* IsIgrAddressRequest::release_client_address() { + clear_has_client_address(); + if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = client_address_; + client_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void IsIgrAddressRequest::set_allocated_client_address(::std::string* client_address) { + if (client_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete client_address_; + } + if (client_address) { + set_has_client_address(); + client_address_ = client_address; + } else { + clear_has_client_address(); + client_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.IsIgrAddressRequest.client_address) +} + +// optional uint32 region = 2; +inline bool IsIgrAddressRequest::has_region() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void IsIgrAddressRequest::set_has_region() { + _has_bits_[0] |= 0x00000002u; +} +inline void IsIgrAddressRequest::clear_has_region() { + _has_bits_[0] &= ~0x00000002u; +} +inline void IsIgrAddressRequest::clear_region() { + region_ = 0u; + clear_has_region(); +} +inline ::google::protobuf::uint32 IsIgrAddressRequest::region() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.IsIgrAddressRequest.region) + return region_; +} +inline void IsIgrAddressRequest::set_region(::google::protobuf::uint32 value) { + set_has_region(); + region_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.IsIgrAddressRequest.region) +} + +// ------------------------------------------------------------------- + +// AccountServiceRegion + +// required uint32 id = 1; +inline bool AccountServiceRegion::has_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AccountServiceRegion::set_has_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void AccountServiceRegion::clear_has_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AccountServiceRegion::clear_id() { + id_ = 0u; + clear_has_id(); +} +inline ::google::protobuf::uint32 AccountServiceRegion::id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountServiceRegion.id) + return id_; +} +inline void AccountServiceRegion::set_id(::google::protobuf::uint32 value) { + set_has_id(); + id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountServiceRegion.id) +} + +// required string shard = 2; +inline bool AccountServiceRegion::has_shard() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void AccountServiceRegion::set_has_shard() { + _has_bits_[0] |= 0x00000002u; +} +inline void AccountServiceRegion::clear_has_shard() { + _has_bits_[0] &= ~0x00000002u; +} +inline void AccountServiceRegion::clear_shard() { + if (shard_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + shard_->clear(); + } + clear_has_shard(); +} +inline const ::std::string& AccountServiceRegion::shard() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountServiceRegion.shard) + return *shard_; +} +inline void AccountServiceRegion::set_shard(const ::std::string& value) { + set_has_shard(); + if (shard_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + shard_ = new ::std::string; + } + shard_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountServiceRegion.shard) +} +inline void AccountServiceRegion::set_shard(const char* value) { + set_has_shard(); + if (shard_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + shard_ = new ::std::string; + } + shard_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountServiceRegion.shard) +} +inline void AccountServiceRegion::set_shard(const char* value, size_t size) { + set_has_shard(); + if (shard_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + shard_ = new ::std::string; + } + shard_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountServiceRegion.shard) +} +inline ::std::string* AccountServiceRegion::mutable_shard() { + set_has_shard(); + if (shard_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + shard_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountServiceRegion.shard) + return shard_; +} +inline ::std::string* AccountServiceRegion::release_shard() { + clear_has_shard(); + if (shard_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = shard_; + shard_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void AccountServiceRegion::set_allocated_shard(::std::string* shard) { + if (shard_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete shard_; + } + if (shard) { + set_has_shard(); + shard_ = shard; + } else { + clear_has_shard(); + shard_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountServiceRegion.shard) +} + +// ------------------------------------------------------------------- + +// AccountServiceConfig + +// repeated .bgs.protocol.account.v1.AccountServiceRegion region = 1; +inline int AccountServiceConfig::region_size() const { + return region_.size(); +} +inline void AccountServiceConfig::clear_region() { + region_.Clear(); +} +inline const ::bgs::protocol::account::v1::AccountServiceRegion& AccountServiceConfig::region(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountServiceConfig.region) + return region_.Get(index); +} +inline ::bgs::protocol::account::v1::AccountServiceRegion* AccountServiceConfig::mutable_region(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountServiceConfig.region) + return region_.Mutable(index); +} +inline ::bgs::protocol::account::v1::AccountServiceRegion* AccountServiceConfig::add_region() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountServiceConfig.region) + return region_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountServiceRegion >& +AccountServiceConfig::region() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountServiceConfig.region) + return region_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountServiceRegion >* +AccountServiceConfig::mutable_region() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountServiceConfig.region) + return ®ion_; +} + +// ------------------------------------------------------------------- + +// GetAccountStateRequest + +// optional .bgs.protocol.EntityId entity_id = 1; +inline bool GetAccountStateRequest::has_entity_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GetAccountStateRequest::set_has_entity_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void GetAccountStateRequest::clear_has_entity_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GetAccountStateRequest::clear_entity_id() { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + clear_has_entity_id(); +} +inline const ::bgs::protocol::EntityId& GetAccountStateRequest::entity_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountStateRequest.entity_id) + return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_; +} +inline ::bgs::protocol::EntityId* GetAccountStateRequest::mutable_entity_id() { + set_has_entity_id(); + if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountStateRequest.entity_id) + return entity_id_; +} +inline ::bgs::protocol::EntityId* GetAccountStateRequest::release_entity_id() { + clear_has_entity_id(); + ::bgs::protocol::EntityId* temp = entity_id_; + entity_id_ = NULL; + return temp; +} +inline void GetAccountStateRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) { + delete entity_id_; + entity_id_ = entity_id; + if (entity_id) { + set_has_entity_id(); + } else { + clear_has_entity_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountStateRequest.entity_id) +} + +// optional uint32 program = 2; +inline bool GetAccountStateRequest::has_program() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GetAccountStateRequest::set_has_program() { + _has_bits_[0] |= 0x00000002u; +} +inline void GetAccountStateRequest::clear_has_program() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GetAccountStateRequest::clear_program() { + program_ = 0u; + clear_has_program(); +} +inline ::google::protobuf::uint32 GetAccountStateRequest::program() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountStateRequest.program) + return program_; +} +inline void GetAccountStateRequest::set_program(::google::protobuf::uint32 value) { + set_has_program(); + program_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountStateRequest.program) +} + +// optional uint32 region = 3; +inline bool GetAccountStateRequest::has_region() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GetAccountStateRequest::set_has_region() { + _has_bits_[0] |= 0x00000004u; +} +inline void GetAccountStateRequest::clear_has_region() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GetAccountStateRequest::clear_region() { + region_ = 0u; + clear_has_region(); +} +inline ::google::protobuf::uint32 GetAccountStateRequest::region() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountStateRequest.region) + return region_; +} +inline void GetAccountStateRequest::set_region(::google::protobuf::uint32 value) { + set_has_region(); + region_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountStateRequest.region) +} + +// optional .bgs.protocol.account.v1.AccountFieldOptions options = 10; +inline bool GetAccountStateRequest::has_options() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void GetAccountStateRequest::set_has_options() { + _has_bits_[0] |= 0x00000008u; +} +inline void GetAccountStateRequest::clear_has_options() { + _has_bits_[0] &= ~0x00000008u; +} +inline void GetAccountStateRequest::clear_options() { + if (options_ != NULL) options_->::bgs::protocol::account::v1::AccountFieldOptions::Clear(); + clear_has_options(); +} +inline const ::bgs::protocol::account::v1::AccountFieldOptions& GetAccountStateRequest::options() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountStateRequest.options) + return options_ != NULL ? *options_ : *default_instance_->options_; +} +inline ::bgs::protocol::account::v1::AccountFieldOptions* GetAccountStateRequest::mutable_options() { + set_has_options(); + if (options_ == NULL) options_ = new ::bgs::protocol::account::v1::AccountFieldOptions; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountStateRequest.options) + return options_; +} +inline ::bgs::protocol::account::v1::AccountFieldOptions* GetAccountStateRequest::release_options() { + clear_has_options(); + ::bgs::protocol::account::v1::AccountFieldOptions* temp = options_; + options_ = NULL; + return temp; +} +inline void GetAccountStateRequest::set_allocated_options(::bgs::protocol::account::v1::AccountFieldOptions* options) { + delete options_; + options_ = options; + if (options) { + set_has_options(); + } else { + clear_has_options(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountStateRequest.options) +} + +// optional .bgs.protocol.account.v1.AccountFieldTags tags = 11; +inline bool GetAccountStateRequest::has_tags() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void GetAccountStateRequest::set_has_tags() { + _has_bits_[0] |= 0x00000010u; +} +inline void GetAccountStateRequest::clear_has_tags() { + _has_bits_[0] &= ~0x00000010u; +} +inline void GetAccountStateRequest::clear_tags() { + if (tags_ != NULL) tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear(); + clear_has_tags(); +} +inline const ::bgs::protocol::account::v1::AccountFieldTags& GetAccountStateRequest::tags() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountStateRequest.tags) + return tags_ != NULL ? *tags_ : *default_instance_->tags_; +} +inline ::bgs::protocol::account::v1::AccountFieldTags* GetAccountStateRequest::mutable_tags() { + set_has_tags(); + if (tags_ == NULL) tags_ = new ::bgs::protocol::account::v1::AccountFieldTags; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountStateRequest.tags) + return tags_; +} +inline ::bgs::protocol::account::v1::AccountFieldTags* GetAccountStateRequest::release_tags() { + clear_has_tags(); + ::bgs::protocol::account::v1::AccountFieldTags* temp = tags_; + tags_ = NULL; + return temp; +} +inline void GetAccountStateRequest::set_allocated_tags(::bgs::protocol::account::v1::AccountFieldTags* tags) { + delete tags_; + tags_ = tags; + if (tags) { + set_has_tags(); + } else { + clear_has_tags(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountStateRequest.tags) +} + +// ------------------------------------------------------------------- + +// GetAccountStateResponse + +// optional .bgs.protocol.account.v1.AccountState state = 1; +inline bool GetAccountStateResponse::has_state() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GetAccountStateResponse::set_has_state() { + _has_bits_[0] |= 0x00000001u; +} +inline void GetAccountStateResponse::clear_has_state() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GetAccountStateResponse::clear_state() { + if (state_ != NULL) state_->::bgs::protocol::account::v1::AccountState::Clear(); + clear_has_state(); +} +inline const ::bgs::protocol::account::v1::AccountState& GetAccountStateResponse::state() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountStateResponse.state) + return state_ != NULL ? *state_ : *default_instance_->state_; +} +inline ::bgs::protocol::account::v1::AccountState* GetAccountStateResponse::mutable_state() { + set_has_state(); + if (state_ == NULL) state_ = new ::bgs::protocol::account::v1::AccountState; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountStateResponse.state) + return state_; +} +inline ::bgs::protocol::account::v1::AccountState* GetAccountStateResponse::release_state() { + clear_has_state(); + ::bgs::protocol::account::v1::AccountState* temp = state_; + state_ = NULL; + return temp; +} +inline void GetAccountStateResponse::set_allocated_state(::bgs::protocol::account::v1::AccountState* state) { + delete state_; + state_ = state; + if (state) { + set_has_state(); + } else { + clear_has_state(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountStateResponse.state) +} + +// optional .bgs.protocol.account.v1.AccountFieldTags tags = 2; +inline bool GetAccountStateResponse::has_tags() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GetAccountStateResponse::set_has_tags() { + _has_bits_[0] |= 0x00000002u; +} +inline void GetAccountStateResponse::clear_has_tags() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GetAccountStateResponse::clear_tags() { + if (tags_ != NULL) tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear(); + clear_has_tags(); +} +inline const ::bgs::protocol::account::v1::AccountFieldTags& GetAccountStateResponse::tags() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountStateResponse.tags) + return tags_ != NULL ? *tags_ : *default_instance_->tags_; +} +inline ::bgs::protocol::account::v1::AccountFieldTags* GetAccountStateResponse::mutable_tags() { + set_has_tags(); + if (tags_ == NULL) tags_ = new ::bgs::protocol::account::v1::AccountFieldTags; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountStateResponse.tags) + return tags_; +} +inline ::bgs::protocol::account::v1::AccountFieldTags* GetAccountStateResponse::release_tags() { + clear_has_tags(); + ::bgs::protocol::account::v1::AccountFieldTags* temp = tags_; + tags_ = NULL; + return temp; +} +inline void GetAccountStateResponse::set_allocated_tags(::bgs::protocol::account::v1::AccountFieldTags* tags) { + delete tags_; + tags_ = tags; + if (tags) { + set_has_tags(); + } else { + clear_has_tags(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountStateResponse.tags) +} + +// ------------------------------------------------------------------- + +// GetGameAccountStateRequest + +// optional .bgs.protocol.EntityId account_id = 1 [deprecated = true]; +inline bool GetGameAccountStateRequest::has_account_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GetGameAccountStateRequest::set_has_account_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void GetGameAccountStateRequest::clear_has_account_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GetGameAccountStateRequest::clear_account_id() { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_account_id(); +} +inline const ::bgs::protocol::EntityId& GetGameAccountStateRequest::account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameAccountStateRequest.account_id) + return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_; +} +inline ::bgs::protocol::EntityId* GetGameAccountStateRequest::mutable_account_id() { + set_has_account_id(); + if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameAccountStateRequest.account_id) + return account_id_; +} +inline ::bgs::protocol::EntityId* GetGameAccountStateRequest::release_account_id() { + clear_has_account_id(); + ::bgs::protocol::EntityId* temp = account_id_; + account_id_ = NULL; + return temp; +} +inline void GetGameAccountStateRequest::set_allocated_account_id(::bgs::protocol::EntityId* account_id) { + delete account_id_; + account_id_ = account_id; + if (account_id) { + set_has_account_id(); + } else { + clear_has_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameAccountStateRequest.account_id) +} + +// optional .bgs.protocol.EntityId game_account_id = 2; +inline bool GetGameAccountStateRequest::has_game_account_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GetGameAccountStateRequest::set_has_game_account_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void GetGameAccountStateRequest::clear_has_game_account_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GetGameAccountStateRequest::clear_game_account_id() { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_game_account_id(); +} +inline const ::bgs::protocol::EntityId& GetGameAccountStateRequest::game_account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameAccountStateRequest.game_account_id) + return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_; +} +inline ::bgs::protocol::EntityId* GetGameAccountStateRequest::mutable_game_account_id() { + set_has_game_account_id(); + if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameAccountStateRequest.game_account_id) + return game_account_id_; +} +inline ::bgs::protocol::EntityId* GetGameAccountStateRequest::release_game_account_id() { + clear_has_game_account_id(); + ::bgs::protocol::EntityId* temp = game_account_id_; + game_account_id_ = NULL; + return temp; +} +inline void GetGameAccountStateRequest::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) { + delete game_account_id_; + game_account_id_ = game_account_id; + if (game_account_id) { + set_has_game_account_id(); + } else { + clear_has_game_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameAccountStateRequest.game_account_id) +} + +// optional .bgs.protocol.account.v1.GameAccountFieldOptions options = 10; +inline bool GetGameAccountStateRequest::has_options() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GetGameAccountStateRequest::set_has_options() { + _has_bits_[0] |= 0x00000004u; +} +inline void GetGameAccountStateRequest::clear_has_options() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GetGameAccountStateRequest::clear_options() { + if (options_ != NULL) options_->::bgs::protocol::account::v1::GameAccountFieldOptions::Clear(); + clear_has_options(); +} +inline const ::bgs::protocol::account::v1::GameAccountFieldOptions& GetGameAccountStateRequest::options() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameAccountStateRequest.options) + return options_ != NULL ? *options_ : *default_instance_->options_; +} +inline ::bgs::protocol::account::v1::GameAccountFieldOptions* GetGameAccountStateRequest::mutable_options() { + set_has_options(); + if (options_ == NULL) options_ = new ::bgs::protocol::account::v1::GameAccountFieldOptions; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameAccountStateRequest.options) + return options_; +} +inline ::bgs::protocol::account::v1::GameAccountFieldOptions* GetGameAccountStateRequest::release_options() { + clear_has_options(); + ::bgs::protocol::account::v1::GameAccountFieldOptions* temp = options_; + options_ = NULL; + return temp; +} +inline void GetGameAccountStateRequest::set_allocated_options(::bgs::protocol::account::v1::GameAccountFieldOptions* options) { + delete options_; + options_ = options; + if (options) { + set_has_options(); + } else { + clear_has_options(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameAccountStateRequest.options) +} + +// optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 11; +inline bool GetGameAccountStateRequest::has_tags() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void GetGameAccountStateRequest::set_has_tags() { + _has_bits_[0] |= 0x00000008u; +} +inline void GetGameAccountStateRequest::clear_has_tags() { + _has_bits_[0] &= ~0x00000008u; +} +inline void GetGameAccountStateRequest::clear_tags() { + if (tags_ != NULL) tags_->::bgs::protocol::account::v1::GameAccountFieldTags::Clear(); + clear_has_tags(); +} +inline const ::bgs::protocol::account::v1::GameAccountFieldTags& GetGameAccountStateRequest::tags() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameAccountStateRequest.tags) + return tags_ != NULL ? *tags_ : *default_instance_->tags_; +} +inline ::bgs::protocol::account::v1::GameAccountFieldTags* GetGameAccountStateRequest::mutable_tags() { + set_has_tags(); + if (tags_ == NULL) tags_ = new ::bgs::protocol::account::v1::GameAccountFieldTags; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameAccountStateRequest.tags) + return tags_; +} +inline ::bgs::protocol::account::v1::GameAccountFieldTags* GetGameAccountStateRequest::release_tags() { + clear_has_tags(); + ::bgs::protocol::account::v1::GameAccountFieldTags* temp = tags_; + tags_ = NULL; + return temp; +} +inline void GetGameAccountStateRequest::set_allocated_tags(::bgs::protocol::account::v1::GameAccountFieldTags* tags) { + delete tags_; + tags_ = tags; + if (tags) { + set_has_tags(); + } else { + clear_has_tags(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameAccountStateRequest.tags) +} + +// ------------------------------------------------------------------- + +// GetGameAccountStateResponse + +// optional .bgs.protocol.account.v1.GameAccountState state = 1; +inline bool GetGameAccountStateResponse::has_state() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GetGameAccountStateResponse::set_has_state() { + _has_bits_[0] |= 0x00000001u; +} +inline void GetGameAccountStateResponse::clear_has_state() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GetGameAccountStateResponse::clear_state() { + if (state_ != NULL) state_->::bgs::protocol::account::v1::GameAccountState::Clear(); + clear_has_state(); +} +inline const ::bgs::protocol::account::v1::GameAccountState& GetGameAccountStateResponse::state() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameAccountStateResponse.state) + return state_ != NULL ? *state_ : *default_instance_->state_; +} +inline ::bgs::protocol::account::v1::GameAccountState* GetGameAccountStateResponse::mutable_state() { + set_has_state(); + if (state_ == NULL) state_ = new ::bgs::protocol::account::v1::GameAccountState; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameAccountStateResponse.state) + return state_; +} +inline ::bgs::protocol::account::v1::GameAccountState* GetGameAccountStateResponse::release_state() { + clear_has_state(); + ::bgs::protocol::account::v1::GameAccountState* temp = state_; + state_ = NULL; + return temp; +} +inline void GetGameAccountStateResponse::set_allocated_state(::bgs::protocol::account::v1::GameAccountState* state) { + delete state_; + state_ = state; + if (state) { + set_has_state(); + } else { + clear_has_state(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameAccountStateResponse.state) +} + +// optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 2; +inline bool GetGameAccountStateResponse::has_tags() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GetGameAccountStateResponse::set_has_tags() { + _has_bits_[0] |= 0x00000002u; +} +inline void GetGameAccountStateResponse::clear_has_tags() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GetGameAccountStateResponse::clear_tags() { + if (tags_ != NULL) tags_->::bgs::protocol::account::v1::GameAccountFieldTags::Clear(); + clear_has_tags(); +} +inline const ::bgs::protocol::account::v1::GameAccountFieldTags& GetGameAccountStateResponse::tags() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameAccountStateResponse.tags) + return tags_ != NULL ? *tags_ : *default_instance_->tags_; +} +inline ::bgs::protocol::account::v1::GameAccountFieldTags* GetGameAccountStateResponse::mutable_tags() { + set_has_tags(); + if (tags_ == NULL) tags_ = new ::bgs::protocol::account::v1::GameAccountFieldTags; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameAccountStateResponse.tags) + return tags_; +} +inline ::bgs::protocol::account::v1::GameAccountFieldTags* GetGameAccountStateResponse::release_tags() { + clear_has_tags(); + ::bgs::protocol::account::v1::GameAccountFieldTags* temp = tags_; + tags_ = NULL; + return temp; +} +inline void GetGameAccountStateResponse::set_allocated_tags(::bgs::protocol::account::v1::GameAccountFieldTags* tags) { + delete tags_; + tags_ = tags; + if (tags) { + set_has_tags(); + } else { + clear_has_tags(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameAccountStateResponse.tags) +} + +// ------------------------------------------------------------------- + +// GetLicensesRequest + +// optional .bgs.protocol.EntityId target_id = 1; +inline bool GetLicensesRequest::has_target_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GetLicensesRequest::set_has_target_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void GetLicensesRequest::clear_has_target_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GetLicensesRequest::clear_target_id() { + if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear(); + clear_has_target_id(); +} +inline const ::bgs::protocol::EntityId& GetLicensesRequest::target_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetLicensesRequest.target_id) + return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_; +} +inline ::bgs::protocol::EntityId* GetLicensesRequest::mutable_target_id() { + set_has_target_id(); + if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetLicensesRequest.target_id) + return target_id_; +} +inline ::bgs::protocol::EntityId* GetLicensesRequest::release_target_id() { + clear_has_target_id(); + ::bgs::protocol::EntityId* temp = target_id_; + target_id_ = NULL; + return temp; +} +inline void GetLicensesRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) { + delete target_id_; + target_id_ = target_id; + if (target_id) { + set_has_target_id(); + } else { + clear_has_target_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetLicensesRequest.target_id) +} + +// optional bool fetch_account_licenses = 2; +inline bool GetLicensesRequest::has_fetch_account_licenses() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GetLicensesRequest::set_has_fetch_account_licenses() { + _has_bits_[0] |= 0x00000002u; +} +inline void GetLicensesRequest::clear_has_fetch_account_licenses() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GetLicensesRequest::clear_fetch_account_licenses() { + fetch_account_licenses_ = false; + clear_has_fetch_account_licenses(); +} +inline bool GetLicensesRequest::fetch_account_licenses() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetLicensesRequest.fetch_account_licenses) + return fetch_account_licenses_; +} +inline void GetLicensesRequest::set_fetch_account_licenses(bool value) { + set_has_fetch_account_licenses(); + fetch_account_licenses_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetLicensesRequest.fetch_account_licenses) +} + +// optional bool fetch_game_account_licenses = 3; +inline bool GetLicensesRequest::has_fetch_game_account_licenses() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GetLicensesRequest::set_has_fetch_game_account_licenses() { + _has_bits_[0] |= 0x00000004u; +} +inline void GetLicensesRequest::clear_has_fetch_game_account_licenses() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GetLicensesRequest::clear_fetch_game_account_licenses() { + fetch_game_account_licenses_ = false; + clear_has_fetch_game_account_licenses(); +} +inline bool GetLicensesRequest::fetch_game_account_licenses() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetLicensesRequest.fetch_game_account_licenses) + return fetch_game_account_licenses_; +} +inline void GetLicensesRequest::set_fetch_game_account_licenses(bool value) { + set_has_fetch_game_account_licenses(); + fetch_game_account_licenses_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetLicensesRequest.fetch_game_account_licenses) +} + +// optional bool fetch_dynamic_account_licenses = 4; +inline bool GetLicensesRequest::has_fetch_dynamic_account_licenses() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void GetLicensesRequest::set_has_fetch_dynamic_account_licenses() { + _has_bits_[0] |= 0x00000008u; +} +inline void GetLicensesRequest::clear_has_fetch_dynamic_account_licenses() { + _has_bits_[0] &= ~0x00000008u; +} +inline void GetLicensesRequest::clear_fetch_dynamic_account_licenses() { + fetch_dynamic_account_licenses_ = false; + clear_has_fetch_dynamic_account_licenses(); +} +inline bool GetLicensesRequest::fetch_dynamic_account_licenses() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetLicensesRequest.fetch_dynamic_account_licenses) + return fetch_dynamic_account_licenses_; +} +inline void GetLicensesRequest::set_fetch_dynamic_account_licenses(bool value) { + set_has_fetch_dynamic_account_licenses(); + fetch_dynamic_account_licenses_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetLicensesRequest.fetch_dynamic_account_licenses) +} + +// optional fixed32 program = 5; +inline bool GetLicensesRequest::has_program() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void GetLicensesRequest::set_has_program() { + _has_bits_[0] |= 0x00000010u; +} +inline void GetLicensesRequest::clear_has_program() { + _has_bits_[0] &= ~0x00000010u; +} +inline void GetLicensesRequest::clear_program() { + program_ = 0u; + clear_has_program(); +} +inline ::google::protobuf::uint32 GetLicensesRequest::program() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetLicensesRequest.program) + return program_; +} +inline void GetLicensesRequest::set_program(::google::protobuf::uint32 value) { + set_has_program(); + program_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetLicensesRequest.program) +} + +// optional bool exclude_unknown_program = 6 [default = false]; +inline bool GetLicensesRequest::has_exclude_unknown_program() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void GetLicensesRequest::set_has_exclude_unknown_program() { + _has_bits_[0] |= 0x00000020u; +} +inline void GetLicensesRequest::clear_has_exclude_unknown_program() { + _has_bits_[0] &= ~0x00000020u; +} +inline void GetLicensesRequest::clear_exclude_unknown_program() { + exclude_unknown_program_ = false; + clear_has_exclude_unknown_program(); +} +inline bool GetLicensesRequest::exclude_unknown_program() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetLicensesRequest.exclude_unknown_program) + return exclude_unknown_program_; +} +inline void GetLicensesRequest::set_exclude_unknown_program(bool value) { + set_has_exclude_unknown_program(); + exclude_unknown_program_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetLicensesRequest.exclude_unknown_program) +} + +// ------------------------------------------------------------------- + +// GetLicensesResponse + +// repeated .bgs.protocol.account.v1.AccountLicense licenses = 1; +inline int GetLicensesResponse::licenses_size() const { + return licenses_.size(); +} +inline void GetLicensesResponse::clear_licenses() { + licenses_.Clear(); +} +inline const ::bgs::protocol::account::v1::AccountLicense& GetLicensesResponse::licenses(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetLicensesResponse.licenses) + return licenses_.Get(index); +} +inline ::bgs::protocol::account::v1::AccountLicense* GetLicensesResponse::mutable_licenses(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetLicensesResponse.licenses) + return licenses_.Mutable(index); +} +inline ::bgs::protocol::account::v1::AccountLicense* GetLicensesResponse::add_licenses() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GetLicensesResponse.licenses) + return licenses_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >& +GetLicensesResponse::licenses() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GetLicensesResponse.licenses) + return licenses_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >* +GetLicensesResponse::mutable_licenses() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GetLicensesResponse.licenses) + return &licenses_; +} + +// ------------------------------------------------------------------- + +// GetGameSessionInfoRequest + +// optional .bgs.protocol.EntityId entity_id = 1; +inline bool GetGameSessionInfoRequest::has_entity_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GetGameSessionInfoRequest::set_has_entity_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void GetGameSessionInfoRequest::clear_has_entity_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GetGameSessionInfoRequest::clear_entity_id() { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + clear_has_entity_id(); +} +inline const ::bgs::protocol::EntityId& GetGameSessionInfoRequest::entity_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameSessionInfoRequest.entity_id) + return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_; +} +inline ::bgs::protocol::EntityId* GetGameSessionInfoRequest::mutable_entity_id() { + set_has_entity_id(); + if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameSessionInfoRequest.entity_id) + return entity_id_; +} +inline ::bgs::protocol::EntityId* GetGameSessionInfoRequest::release_entity_id() { + clear_has_entity_id(); + ::bgs::protocol::EntityId* temp = entity_id_; + entity_id_ = NULL; + return temp; +} +inline void GetGameSessionInfoRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) { + delete entity_id_; + entity_id_ = entity_id; + if (entity_id) { + set_has_entity_id(); + } else { + clear_has_entity_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameSessionInfoRequest.entity_id) +} + +// ------------------------------------------------------------------- + +// GetGameSessionInfoResponse + +// optional .bgs.protocol.account.v1.GameSessionInfo session_info = 2; +inline bool GetGameSessionInfoResponse::has_session_info() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GetGameSessionInfoResponse::set_has_session_info() { + _has_bits_[0] |= 0x00000001u; +} +inline void GetGameSessionInfoResponse::clear_has_session_info() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GetGameSessionInfoResponse::clear_session_info() { + if (session_info_ != NULL) session_info_->::bgs::protocol::account::v1::GameSessionInfo::Clear(); + clear_has_session_info(); +} +inline const ::bgs::protocol::account::v1::GameSessionInfo& GetGameSessionInfoResponse::session_info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameSessionInfoResponse.session_info) + return session_info_ != NULL ? *session_info_ : *default_instance_->session_info_; +} +inline ::bgs::protocol::account::v1::GameSessionInfo* GetGameSessionInfoResponse::mutable_session_info() { + set_has_session_info(); + if (session_info_ == NULL) session_info_ = new ::bgs::protocol::account::v1::GameSessionInfo; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameSessionInfoResponse.session_info) + return session_info_; +} +inline ::bgs::protocol::account::v1::GameSessionInfo* GetGameSessionInfoResponse::release_session_info() { + clear_has_session_info(); + ::bgs::protocol::account::v1::GameSessionInfo* temp = session_info_; + session_info_ = NULL; + return temp; +} +inline void GetGameSessionInfoResponse::set_allocated_session_info(::bgs::protocol::account::v1::GameSessionInfo* session_info) { + delete session_info_; + session_info_ = session_info; + if (session_info) { + set_has_session_info(); + } else { + clear_has_session_info(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameSessionInfoResponse.session_info) +} + +// ------------------------------------------------------------------- + +// GetGameTimeRemainingInfoRequest + +// optional .bgs.protocol.EntityId game_account_id = 1; +inline bool GetGameTimeRemainingInfoRequest::has_game_account_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GetGameTimeRemainingInfoRequest::set_has_game_account_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void GetGameTimeRemainingInfoRequest::clear_has_game_account_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GetGameTimeRemainingInfoRequest::clear_game_account_id() { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_game_account_id(); +} +inline const ::bgs::protocol::EntityId& GetGameTimeRemainingInfoRequest::game_account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest.game_account_id) + return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_; +} +inline ::bgs::protocol::EntityId* GetGameTimeRemainingInfoRequest::mutable_game_account_id() { + set_has_game_account_id(); + if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest.game_account_id) + return game_account_id_; +} +inline ::bgs::protocol::EntityId* GetGameTimeRemainingInfoRequest::release_game_account_id() { + clear_has_game_account_id(); + ::bgs::protocol::EntityId* temp = game_account_id_; + game_account_id_ = NULL; + return temp; +} +inline void GetGameTimeRemainingInfoRequest::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) { + delete game_account_id_; + game_account_id_ = game_account_id; + if (game_account_id) { + set_has_game_account_id(); + } else { + clear_has_game_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest.game_account_id) +} + +// optional .bgs.protocol.EntityId account_id = 2; +inline bool GetGameTimeRemainingInfoRequest::has_account_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GetGameTimeRemainingInfoRequest::set_has_account_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void GetGameTimeRemainingInfoRequest::clear_has_account_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GetGameTimeRemainingInfoRequest::clear_account_id() { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_account_id(); +} +inline const ::bgs::protocol::EntityId& GetGameTimeRemainingInfoRequest::account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest.account_id) + return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_; +} +inline ::bgs::protocol::EntityId* GetGameTimeRemainingInfoRequest::mutable_account_id() { + set_has_account_id(); + if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest.account_id) + return account_id_; +} +inline ::bgs::protocol::EntityId* GetGameTimeRemainingInfoRequest::release_account_id() { + clear_has_account_id(); + ::bgs::protocol::EntityId* temp = account_id_; + account_id_ = NULL; + return temp; +} +inline void GetGameTimeRemainingInfoRequest::set_allocated_account_id(::bgs::protocol::EntityId* account_id) { + delete account_id_; + account_id_ = account_id; + if (account_id) { + set_has_account_id(); + } else { + clear_has_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest.account_id) +} + +// ------------------------------------------------------------------- + +// GetGameTimeRemainingInfoResponse + +// optional .bgs.protocol.account.v1.GameTimeRemainingInfo game_time_remaining_info = 1; +inline bool GetGameTimeRemainingInfoResponse::has_game_time_remaining_info() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GetGameTimeRemainingInfoResponse::set_has_game_time_remaining_info() { + _has_bits_[0] |= 0x00000001u; +} +inline void GetGameTimeRemainingInfoResponse::clear_has_game_time_remaining_info() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GetGameTimeRemainingInfoResponse::clear_game_time_remaining_info() { + if (game_time_remaining_info_ != NULL) game_time_remaining_info_->::bgs::protocol::account::v1::GameTimeRemainingInfo::Clear(); + clear_has_game_time_remaining_info(); +} +inline const ::bgs::protocol::account::v1::GameTimeRemainingInfo& GetGameTimeRemainingInfoResponse::game_time_remaining_info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse.game_time_remaining_info) + return game_time_remaining_info_ != NULL ? *game_time_remaining_info_ : *default_instance_->game_time_remaining_info_; +} +inline ::bgs::protocol::account::v1::GameTimeRemainingInfo* GetGameTimeRemainingInfoResponse::mutable_game_time_remaining_info() { + set_has_game_time_remaining_info(); + if (game_time_remaining_info_ == NULL) game_time_remaining_info_ = new ::bgs::protocol::account::v1::GameTimeRemainingInfo; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse.game_time_remaining_info) + return game_time_remaining_info_; +} +inline ::bgs::protocol::account::v1::GameTimeRemainingInfo* GetGameTimeRemainingInfoResponse::release_game_time_remaining_info() { + clear_has_game_time_remaining_info(); + ::bgs::protocol::account::v1::GameTimeRemainingInfo* temp = game_time_remaining_info_; + game_time_remaining_info_ = NULL; + return temp; +} +inline void GetGameTimeRemainingInfoResponse::set_allocated_game_time_remaining_info(::bgs::protocol::account::v1::GameTimeRemainingInfo* game_time_remaining_info) { + delete game_time_remaining_info_; + game_time_remaining_info_ = game_time_remaining_info; + if (game_time_remaining_info) { + set_has_game_time_remaining_info(); + } else { + clear_has_game_time_remaining_info(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse.game_time_remaining_info) +} + +// ------------------------------------------------------------------- + +// GetCAISInfoRequest + +// optional .bgs.protocol.EntityId entity_id = 1; +inline bool GetCAISInfoRequest::has_entity_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GetCAISInfoRequest::set_has_entity_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void GetCAISInfoRequest::clear_has_entity_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GetCAISInfoRequest::clear_entity_id() { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + clear_has_entity_id(); +} +inline const ::bgs::protocol::EntityId& GetCAISInfoRequest::entity_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetCAISInfoRequest.entity_id) + return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_; +} +inline ::bgs::protocol::EntityId* GetCAISInfoRequest::mutable_entity_id() { + set_has_entity_id(); + if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetCAISInfoRequest.entity_id) + return entity_id_; +} +inline ::bgs::protocol::EntityId* GetCAISInfoRequest::release_entity_id() { + clear_has_entity_id(); + ::bgs::protocol::EntityId* temp = entity_id_; + entity_id_ = NULL; + return temp; +} +inline void GetCAISInfoRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) { + delete entity_id_; + entity_id_ = entity_id; + if (entity_id) { + set_has_entity_id(); + } else { + clear_has_entity_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetCAISInfoRequest.entity_id) +} + +// ------------------------------------------------------------------- + +// GetCAISInfoResponse + +// optional .bgs.protocol.account.v1.CAIS cais_info = 1; +inline bool GetCAISInfoResponse::has_cais_info() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GetCAISInfoResponse::set_has_cais_info() { + _has_bits_[0] |= 0x00000001u; +} +inline void GetCAISInfoResponse::clear_has_cais_info() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GetCAISInfoResponse::clear_cais_info() { + if (cais_info_ != NULL) cais_info_->::bgs::protocol::account::v1::CAIS::Clear(); + clear_has_cais_info(); +} +inline const ::bgs::protocol::account::v1::CAIS& GetCAISInfoResponse::cais_info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetCAISInfoResponse.cais_info) + return cais_info_ != NULL ? *cais_info_ : *default_instance_->cais_info_; +} +inline ::bgs::protocol::account::v1::CAIS* GetCAISInfoResponse::mutable_cais_info() { + set_has_cais_info(); + if (cais_info_ == NULL) cais_info_ = new ::bgs::protocol::account::v1::CAIS; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetCAISInfoResponse.cais_info) + return cais_info_; +} +inline ::bgs::protocol::account::v1::CAIS* GetCAISInfoResponse::release_cais_info() { + clear_has_cais_info(); + ::bgs::protocol::account::v1::CAIS* temp = cais_info_; + cais_info_ = NULL; + return temp; +} +inline void GetCAISInfoResponse::set_allocated_cais_info(::bgs::protocol::account::v1::CAIS* cais_info) { + delete cais_info_; + cais_info_ = cais_info; + if (cais_info) { + set_has_cais_info(); + } else { + clear_has_cais_info(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetCAISInfoResponse.cais_info) +} + +// ------------------------------------------------------------------- + +// ForwardCacheExpireRequest + +// optional .bgs.protocol.EntityId entity_id = 1; +inline bool ForwardCacheExpireRequest::has_entity_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ForwardCacheExpireRequest::set_has_entity_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void ForwardCacheExpireRequest::clear_has_entity_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ForwardCacheExpireRequest::clear_entity_id() { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + clear_has_entity_id(); +} +inline const ::bgs::protocol::EntityId& ForwardCacheExpireRequest::entity_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ForwardCacheExpireRequest.entity_id) + return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_; +} +inline ::bgs::protocol::EntityId* ForwardCacheExpireRequest::mutable_entity_id() { + set_has_entity_id(); + if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.ForwardCacheExpireRequest.entity_id) + return entity_id_; +} +inline ::bgs::protocol::EntityId* ForwardCacheExpireRequest::release_entity_id() { + clear_has_entity_id(); + ::bgs::protocol::EntityId* temp = entity_id_; + entity_id_ = NULL; + return temp; +} +inline void ForwardCacheExpireRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) { + delete entity_id_; + entity_id_ = entity_id; + if (entity_id) { + set_has_entity_id(); + } else { + clear_has_entity_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.ForwardCacheExpireRequest.entity_id) +} + +// ------------------------------------------------------------------- + +// GetAuthorizedDataRequest + +// optional .bgs.protocol.EntityId entity_id = 1; +inline bool GetAuthorizedDataRequest::has_entity_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GetAuthorizedDataRequest::set_has_entity_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void GetAuthorizedDataRequest::clear_has_entity_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GetAuthorizedDataRequest::clear_entity_id() { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + clear_has_entity_id(); +} +inline const ::bgs::protocol::EntityId& GetAuthorizedDataRequest::entity_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAuthorizedDataRequest.entity_id) + return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_; +} +inline ::bgs::protocol::EntityId* GetAuthorizedDataRequest::mutable_entity_id() { + set_has_entity_id(); + if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAuthorizedDataRequest.entity_id) + return entity_id_; +} +inline ::bgs::protocol::EntityId* GetAuthorizedDataRequest::release_entity_id() { + clear_has_entity_id(); + ::bgs::protocol::EntityId* temp = entity_id_; + entity_id_ = NULL; + return temp; +} +inline void GetAuthorizedDataRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) { + delete entity_id_; + entity_id_ = entity_id; + if (entity_id) { + set_has_entity_id(); + } else { + clear_has_entity_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAuthorizedDataRequest.entity_id) +} + +// repeated string tag = 2; +inline int GetAuthorizedDataRequest::tag_size() const { + return tag_.size(); +} +inline void GetAuthorizedDataRequest::clear_tag() { + tag_.Clear(); +} +inline const ::std::string& GetAuthorizedDataRequest::tag(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag) + return tag_.Get(index); +} +inline ::std::string* GetAuthorizedDataRequest::mutable_tag(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag) + return tag_.Mutable(index); +} +inline void GetAuthorizedDataRequest::set_tag(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag) + tag_.Mutable(index)->assign(value); +} +inline void GetAuthorizedDataRequest::set_tag(int index, const char* value) { + tag_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag) +} +inline void GetAuthorizedDataRequest::set_tag(int index, const char* value, size_t size) { + tag_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag) +} +inline ::std::string* GetAuthorizedDataRequest::add_tag() { + return tag_.Add(); +} +inline void GetAuthorizedDataRequest::add_tag(const ::std::string& value) { + tag_.Add()->assign(value); + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag) +} +inline void GetAuthorizedDataRequest::add_tag(const char* value) { + tag_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag) +} +inline void GetAuthorizedDataRequest::add_tag(const char* value, size_t size) { + tag_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag) +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +GetAuthorizedDataRequest::tag() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag) + return tag_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +GetAuthorizedDataRequest::mutable_tag() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag) + return &tag_; +} + +// optional bool privileged_network = 3; +inline bool GetAuthorizedDataRequest::has_privileged_network() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GetAuthorizedDataRequest::set_has_privileged_network() { + _has_bits_[0] |= 0x00000004u; +} +inline void GetAuthorizedDataRequest::clear_has_privileged_network() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GetAuthorizedDataRequest::clear_privileged_network() { + privileged_network_ = false; + clear_has_privileged_network(); +} +inline bool GetAuthorizedDataRequest::privileged_network() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAuthorizedDataRequest.privileged_network) + return privileged_network_; +} +inline void GetAuthorizedDataRequest::set_privileged_network(bool value) { + set_has_privileged_network(); + privileged_network_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAuthorizedDataRequest.privileged_network) +} + +// ------------------------------------------------------------------- + +// GetAuthorizedDataResponse + +// repeated .bgs.protocol.account.v1.AuthorizedData data = 1; +inline int GetAuthorizedDataResponse::data_size() const { + return data_.size(); +} +inline void GetAuthorizedDataResponse::clear_data() { + data_.Clear(); +} +inline const ::bgs::protocol::account::v1::AuthorizedData& GetAuthorizedDataResponse::data(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAuthorizedDataResponse.data) + return data_.Get(index); +} +inline ::bgs::protocol::account::v1::AuthorizedData* GetAuthorizedDataResponse::mutable_data(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAuthorizedDataResponse.data) + return data_.Mutable(index); +} +inline ::bgs::protocol::account::v1::AuthorizedData* GetAuthorizedDataResponse::add_data() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GetAuthorizedDataResponse.data) + return data_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AuthorizedData >& +GetAuthorizedDataResponse::data() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GetAuthorizedDataResponse.data) + return data_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AuthorizedData >* +GetAuthorizedDataResponse::mutable_data() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GetAuthorizedDataResponse.data) + return &data_; +} + +// ------------------------------------------------------------------- + +// AccountStateNotification + +// optional .bgs.protocol.account.v1.AccountState account_state = 1; +inline bool AccountStateNotification::has_account_state() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AccountStateNotification::set_has_account_state() { + _has_bits_[0] |= 0x00000001u; +} +inline void AccountStateNotification::clear_has_account_state() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AccountStateNotification::clear_account_state() { + if (account_state_ != NULL) account_state_->::bgs::protocol::account::v1::AccountState::Clear(); + clear_has_account_state(); +} +inline const ::bgs::protocol::account::v1::AccountState& AccountStateNotification::account_state() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountStateNotification.account_state) + return account_state_ != NULL ? *account_state_ : *default_instance_->account_state_; +} +inline ::bgs::protocol::account::v1::AccountState* AccountStateNotification::mutable_account_state() { + set_has_account_state(); + if (account_state_ == NULL) account_state_ = new ::bgs::protocol::account::v1::AccountState; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountStateNotification.account_state) + return account_state_; +} +inline ::bgs::protocol::account::v1::AccountState* AccountStateNotification::release_account_state() { + clear_has_account_state(); + ::bgs::protocol::account::v1::AccountState* temp = account_state_; + account_state_ = NULL; + return temp; +} +inline void AccountStateNotification::set_allocated_account_state(::bgs::protocol::account::v1::AccountState* account_state) { + delete account_state_; + account_state_ = account_state; + if (account_state) { + set_has_account_state(); + } else { + clear_has_account_state(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountStateNotification.account_state) +} + +// optional uint64 subscriber_id = 2; +inline bool AccountStateNotification::has_subscriber_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void AccountStateNotification::set_has_subscriber_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void AccountStateNotification::clear_has_subscriber_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void AccountStateNotification::clear_subscriber_id() { + subscriber_id_ = GOOGLE_ULONGLONG(0); + clear_has_subscriber_id(); +} +inline ::google::protobuf::uint64 AccountStateNotification::subscriber_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountStateNotification.subscriber_id) + return subscriber_id_; +} +inline void AccountStateNotification::set_subscriber_id(::google::protobuf::uint64 value) { + set_has_subscriber_id(); + subscriber_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountStateNotification.subscriber_id) +} + +// optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3; +inline bool AccountStateNotification::has_account_tags() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void AccountStateNotification::set_has_account_tags() { + _has_bits_[0] |= 0x00000004u; +} +inline void AccountStateNotification::clear_has_account_tags() { + _has_bits_[0] &= ~0x00000004u; +} +inline void AccountStateNotification::clear_account_tags() { + if (account_tags_ != NULL) account_tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear(); + clear_has_account_tags(); +} +inline const ::bgs::protocol::account::v1::AccountFieldTags& AccountStateNotification::account_tags() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountStateNotification.account_tags) + return account_tags_ != NULL ? *account_tags_ : *default_instance_->account_tags_; +} +inline ::bgs::protocol::account::v1::AccountFieldTags* AccountStateNotification::mutable_account_tags() { + set_has_account_tags(); + if (account_tags_ == NULL) account_tags_ = new ::bgs::protocol::account::v1::AccountFieldTags; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountStateNotification.account_tags) + return account_tags_; +} +inline ::bgs::protocol::account::v1::AccountFieldTags* AccountStateNotification::release_account_tags() { + clear_has_account_tags(); + ::bgs::protocol::account::v1::AccountFieldTags* temp = account_tags_; + account_tags_ = NULL; + return temp; +} +inline void AccountStateNotification::set_allocated_account_tags(::bgs::protocol::account::v1::AccountFieldTags* account_tags) { + delete account_tags_; + account_tags_ = account_tags; + if (account_tags) { + set_has_account_tags(); + } else { + clear_has_account_tags(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountStateNotification.account_tags) +} + +// optional bool subscription_completed = 4; +inline bool AccountStateNotification::has_subscription_completed() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void AccountStateNotification::set_has_subscription_completed() { + _has_bits_[0] |= 0x00000008u; +} +inline void AccountStateNotification::clear_has_subscription_completed() { + _has_bits_[0] &= ~0x00000008u; +} +inline void AccountStateNotification::clear_subscription_completed() { + subscription_completed_ = false; + clear_has_subscription_completed(); +} +inline bool AccountStateNotification::subscription_completed() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountStateNotification.subscription_completed) + return subscription_completed_; +} +inline void AccountStateNotification::set_subscription_completed(bool value) { + set_has_subscription_completed(); + subscription_completed_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountStateNotification.subscription_completed) +} + +// ------------------------------------------------------------------- + +// GameAccountStateNotification + +// optional .bgs.protocol.account.v1.GameAccountState game_account_state = 1; +inline bool GameAccountStateNotification::has_game_account_state() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GameAccountStateNotification::set_has_game_account_state() { + _has_bits_[0] |= 0x00000001u; +} +inline void GameAccountStateNotification::clear_has_game_account_state() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GameAccountStateNotification::clear_game_account_state() { + if (game_account_state_ != NULL) game_account_state_->::bgs::protocol::account::v1::GameAccountState::Clear(); + clear_has_game_account_state(); +} +inline const ::bgs::protocol::account::v1::GameAccountState& GameAccountStateNotification::game_account_state() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountStateNotification.game_account_state) + return game_account_state_ != NULL ? *game_account_state_ : *default_instance_->game_account_state_; +} +inline ::bgs::protocol::account::v1::GameAccountState* GameAccountStateNotification::mutable_game_account_state() { + set_has_game_account_state(); + if (game_account_state_ == NULL) game_account_state_ = new ::bgs::protocol::account::v1::GameAccountState; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountStateNotification.game_account_state) + return game_account_state_; +} +inline ::bgs::protocol::account::v1::GameAccountState* GameAccountStateNotification::release_game_account_state() { + clear_has_game_account_state(); + ::bgs::protocol::account::v1::GameAccountState* temp = game_account_state_; + game_account_state_ = NULL; + return temp; +} +inline void GameAccountStateNotification::set_allocated_game_account_state(::bgs::protocol::account::v1::GameAccountState* game_account_state) { + delete game_account_state_; + game_account_state_ = game_account_state; + if (game_account_state) { + set_has_game_account_state(); + } else { + clear_has_game_account_state(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountStateNotification.game_account_state) +} + +// optional uint64 subscriber_id = 2; +inline bool GameAccountStateNotification::has_subscriber_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GameAccountStateNotification::set_has_subscriber_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void GameAccountStateNotification::clear_has_subscriber_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GameAccountStateNotification::clear_subscriber_id() { + subscriber_id_ = GOOGLE_ULONGLONG(0); + clear_has_subscriber_id(); +} +inline ::google::protobuf::uint64 GameAccountStateNotification::subscriber_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountStateNotification.subscriber_id) + return subscriber_id_; +} +inline void GameAccountStateNotification::set_subscriber_id(::google::protobuf::uint64 value) { + set_has_subscriber_id(); + subscriber_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountStateNotification.subscriber_id) +} + +// optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 3; +inline bool GameAccountStateNotification::has_game_account_tags() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GameAccountStateNotification::set_has_game_account_tags() { + _has_bits_[0] |= 0x00000004u; +} +inline void GameAccountStateNotification::clear_has_game_account_tags() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GameAccountStateNotification::clear_game_account_tags() { + if (game_account_tags_ != NULL) game_account_tags_->::bgs::protocol::account::v1::GameAccountFieldTags::Clear(); + clear_has_game_account_tags(); +} +inline const ::bgs::protocol::account::v1::GameAccountFieldTags& GameAccountStateNotification::game_account_tags() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountStateNotification.game_account_tags) + return game_account_tags_ != NULL ? *game_account_tags_ : *default_instance_->game_account_tags_; +} +inline ::bgs::protocol::account::v1::GameAccountFieldTags* GameAccountStateNotification::mutable_game_account_tags() { + set_has_game_account_tags(); + if (game_account_tags_ == NULL) game_account_tags_ = new ::bgs::protocol::account::v1::GameAccountFieldTags; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountStateNotification.game_account_tags) + return game_account_tags_; +} +inline ::bgs::protocol::account::v1::GameAccountFieldTags* GameAccountStateNotification::release_game_account_tags() { + clear_has_game_account_tags(); + ::bgs::protocol::account::v1::GameAccountFieldTags* temp = game_account_tags_; + game_account_tags_ = NULL; + return temp; +} +inline void GameAccountStateNotification::set_allocated_game_account_tags(::bgs::protocol::account::v1::GameAccountFieldTags* game_account_tags) { + delete game_account_tags_; + game_account_tags_ = game_account_tags; + if (game_account_tags) { + set_has_game_account_tags(); + } else { + clear_has_game_account_tags(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountStateNotification.game_account_tags) +} + +// optional bool subscription_completed = 4; +inline bool GameAccountStateNotification::has_subscription_completed() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void GameAccountStateNotification::set_has_subscription_completed() { + _has_bits_[0] |= 0x00000008u; +} +inline void GameAccountStateNotification::clear_has_subscription_completed() { + _has_bits_[0] &= ~0x00000008u; +} +inline void GameAccountStateNotification::clear_subscription_completed() { + subscription_completed_ = false; + clear_has_subscription_completed(); +} +inline bool GameAccountStateNotification::subscription_completed() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountStateNotification.subscription_completed) + return subscription_completed_; +} +inline void GameAccountStateNotification::set_subscription_completed(bool value) { + set_has_subscription_completed(); + subscription_completed_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountStateNotification.subscription_completed) +} + +// ------------------------------------------------------------------- + +// GameAccountNotification + +// repeated .bgs.protocol.account.v1.GameAccountList game_accounts = 1; +inline int GameAccountNotification::game_accounts_size() const { + return game_accounts_.size(); +} +inline void GameAccountNotification::clear_game_accounts() { + game_accounts_.Clear(); +} +inline const ::bgs::protocol::account::v1::GameAccountList& GameAccountNotification::game_accounts(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountNotification.game_accounts) + return game_accounts_.Get(index); +} +inline ::bgs::protocol::account::v1::GameAccountList* GameAccountNotification::mutable_game_accounts(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountNotification.game_accounts) + return game_accounts_.Mutable(index); +} +inline ::bgs::protocol::account::v1::GameAccountList* GameAccountNotification::add_game_accounts() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GameAccountNotification.game_accounts) + return game_accounts_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList >& +GameAccountNotification::game_accounts() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GameAccountNotification.game_accounts) + return game_accounts_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList >* +GameAccountNotification::mutable_game_accounts() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GameAccountNotification.game_accounts) + return &game_accounts_; +} + +// optional uint64 subscriber_id = 2; +inline bool GameAccountNotification::has_subscriber_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GameAccountNotification::set_has_subscriber_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void GameAccountNotification::clear_has_subscriber_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GameAccountNotification::clear_subscriber_id() { + subscriber_id_ = GOOGLE_ULONGLONG(0); + clear_has_subscriber_id(); +} +inline ::google::protobuf::uint64 GameAccountNotification::subscriber_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountNotification.subscriber_id) + return subscriber_id_; +} +inline void GameAccountNotification::set_subscriber_id(::google::protobuf::uint64 value) { + set_has_subscriber_id(); + subscriber_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountNotification.subscriber_id) +} + +// optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3; +inline bool GameAccountNotification::has_account_tags() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GameAccountNotification::set_has_account_tags() { + _has_bits_[0] |= 0x00000004u; +} +inline void GameAccountNotification::clear_has_account_tags() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GameAccountNotification::clear_account_tags() { + if (account_tags_ != NULL) account_tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear(); + clear_has_account_tags(); +} +inline const ::bgs::protocol::account::v1::AccountFieldTags& GameAccountNotification::account_tags() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountNotification.account_tags) + return account_tags_ != NULL ? *account_tags_ : *default_instance_->account_tags_; +} +inline ::bgs::protocol::account::v1::AccountFieldTags* GameAccountNotification::mutable_account_tags() { + set_has_account_tags(); + if (account_tags_ == NULL) account_tags_ = new ::bgs::protocol::account::v1::AccountFieldTags; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountNotification.account_tags) + return account_tags_; +} +inline ::bgs::protocol::account::v1::AccountFieldTags* GameAccountNotification::release_account_tags() { + clear_has_account_tags(); + ::bgs::protocol::account::v1::AccountFieldTags* temp = account_tags_; + account_tags_ = NULL; + return temp; +} +inline void GameAccountNotification::set_allocated_account_tags(::bgs::protocol::account::v1::AccountFieldTags* account_tags) { + delete account_tags_; + account_tags_ = account_tags; + if (account_tags) { + set_has_account_tags(); + } else { + clear_has_account_tags(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountNotification.account_tags) +} + +// ------------------------------------------------------------------- + +// GameAccountSessionNotification + +// optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1; +inline bool GameAccountSessionNotification::has_game_account() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GameAccountSessionNotification::set_has_game_account() { + _has_bits_[0] |= 0x00000001u; +} +inline void GameAccountSessionNotification::clear_has_game_account() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GameAccountSessionNotification::clear_game_account() { + if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear(); + clear_has_game_account(); +} +inline const ::bgs::protocol::account::v1::GameAccountHandle& GameAccountSessionNotification::game_account() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountSessionNotification.game_account) + return game_account_ != NULL ? *game_account_ : *default_instance_->game_account_; +} +inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountSessionNotification::mutable_game_account() { + set_has_game_account(); + if (game_account_ == NULL) game_account_ = new ::bgs::protocol::account::v1::GameAccountHandle; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountSessionNotification.game_account) + return game_account_; +} +inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountSessionNotification::release_game_account() { + clear_has_game_account(); + ::bgs::protocol::account::v1::GameAccountHandle* temp = game_account_; + game_account_ = NULL; + return temp; +} +inline void GameAccountSessionNotification::set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account) { + delete game_account_; + game_account_ = game_account; + if (game_account) { + set_has_game_account(); + } else { + clear_has_game_account(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountSessionNotification.game_account) +} + +// optional .bgs.protocol.account.v1.GameSessionUpdateInfo session_info = 2; +inline bool GameAccountSessionNotification::has_session_info() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GameAccountSessionNotification::set_has_session_info() { + _has_bits_[0] |= 0x00000002u; +} +inline void GameAccountSessionNotification::clear_has_session_info() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GameAccountSessionNotification::clear_session_info() { + if (session_info_ != NULL) session_info_->::bgs::protocol::account::v1::GameSessionUpdateInfo::Clear(); + clear_has_session_info(); +} +inline const ::bgs::protocol::account::v1::GameSessionUpdateInfo& GameAccountSessionNotification::session_info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountSessionNotification.session_info) + return session_info_ != NULL ? *session_info_ : *default_instance_->session_info_; +} +inline ::bgs::protocol::account::v1::GameSessionUpdateInfo* GameAccountSessionNotification::mutable_session_info() { + set_has_session_info(); + if (session_info_ == NULL) session_info_ = new ::bgs::protocol::account::v1::GameSessionUpdateInfo; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountSessionNotification.session_info) + return session_info_; +} +inline ::bgs::protocol::account::v1::GameSessionUpdateInfo* GameAccountSessionNotification::release_session_info() { + clear_has_session_info(); + ::bgs::protocol::account::v1::GameSessionUpdateInfo* temp = session_info_; + session_info_ = NULL; + return temp; +} +inline void GameAccountSessionNotification::set_allocated_session_info(::bgs::protocol::account::v1::GameSessionUpdateInfo* session_info) { + delete session_info_; + session_info_ = session_info; + if (session_info) { + set_has_session_info(); + } else { + clear_has_session_info(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountSessionNotification.session_info) +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace account +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_account_5fservice_2eproto__INCLUDED diff --git a/src/server/proto/Client/account_types.pb.cc b/src/server/proto/Client/account_types.pb.cc new file mode 100644 index 00000000000..9659cfa2c84 --- /dev/null +++ b/src/server/proto/Client/account_types.pb.cc @@ -0,0 +1,15012 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: account_types.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "account_types.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { +namespace account { +namespace v1 { + +namespace { + +const ::google::protobuf::Descriptor* AccountId_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AccountId_reflection_ = NULL; +const ::google::protobuf::Descriptor* AccountLicense_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AccountLicense_reflection_ = NULL; +const ::google::protobuf::Descriptor* AccountCredential_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AccountCredential_reflection_ = NULL; +const ::google::protobuf::Descriptor* AccountBlob_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AccountBlob_reflection_ = NULL; +const ::google::protobuf::Descriptor* AccountBlobList_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AccountBlobList_reflection_ = NULL; +const ::google::protobuf::Descriptor* GameAccountHandle_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GameAccountHandle_reflection_ = NULL; +const ::google::protobuf::Descriptor* GameAccountLink_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GameAccountLink_reflection_ = NULL; +const ::google::protobuf::Descriptor* GameAccountBlob_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GameAccountBlob_reflection_ = NULL; +const ::google::protobuf::Descriptor* GameAccountBlobList_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GameAccountBlobList_reflection_ = NULL; +const ::google::protobuf::Descriptor* AccountReference_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AccountReference_reflection_ = NULL; +const ::google::protobuf::Descriptor* Identity_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Identity_reflection_ = NULL; +const ::google::protobuf::Descriptor* ProgramTag_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ProgramTag_reflection_ = NULL; +const ::google::protobuf::Descriptor* RegionTag_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + RegionTag_reflection_ = NULL; +const ::google::protobuf::Descriptor* AccountFieldTags_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AccountFieldTags_reflection_ = NULL; +const ::google::protobuf::Descriptor* GameAccountFieldTags_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GameAccountFieldTags_reflection_ = NULL; +const ::google::protobuf::Descriptor* AccountFieldOptions_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AccountFieldOptions_reflection_ = NULL; +const ::google::protobuf::Descriptor* GameAccountFieldOptions_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GameAccountFieldOptions_reflection_ = NULL; +const ::google::protobuf::Descriptor* SubscriberReference_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SubscriberReference_reflection_ = NULL; +const ::google::protobuf::Descriptor* AccountLevelInfo_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AccountLevelInfo_reflection_ = NULL; +const ::google::protobuf::Descriptor* PrivacyInfo_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + PrivacyInfo_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* PrivacyInfo_GameInfoPrivacy_descriptor_ = NULL; +const ::google::protobuf::Descriptor* ParentalControlInfo_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ParentalControlInfo_reflection_ = NULL; +const ::google::protobuf::Descriptor* GameLevelInfo_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GameLevelInfo_reflection_ = NULL; +const ::google::protobuf::Descriptor* GameTimeInfo_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GameTimeInfo_reflection_ = NULL; +const ::google::protobuf::Descriptor* GameTimeRemainingInfo_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GameTimeRemainingInfo_reflection_ = NULL; +const ::google::protobuf::Descriptor* GameStatus_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GameStatus_reflection_ = NULL; +const ::google::protobuf::Descriptor* RAFInfo_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + RAFInfo_reflection_ = NULL; +const ::google::protobuf::Descriptor* GameSessionInfo_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GameSessionInfo_reflection_ = NULL; +const ::google::protobuf::Descriptor* GameSessionUpdateInfo_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GameSessionUpdateInfo_reflection_ = NULL; +const ::google::protobuf::Descriptor* GameSessionLocation_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GameSessionLocation_reflection_ = NULL; +const ::google::protobuf::Descriptor* CAIS_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + CAIS_reflection_ = NULL; +const ::google::protobuf::Descriptor* GameAccountList_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GameAccountList_reflection_ = NULL; +const ::google::protobuf::Descriptor* AccountState_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AccountState_reflection_ = NULL; +const ::google::protobuf::Descriptor* AccountStateTagged_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AccountStateTagged_reflection_ = NULL; +const ::google::protobuf::Descriptor* GameAccountState_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GameAccountState_reflection_ = NULL; +const ::google::protobuf::Descriptor* GameAccountStateTagged_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GameAccountStateTagged_reflection_ = NULL; +const ::google::protobuf::Descriptor* AuthorizedData_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AuthorizedData_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* IdentityVerificationStatus_descriptor_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_account_5ftypes_2eproto() { + protobuf_AddDesc_account_5ftypes_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "account_types.proto"); + GOOGLE_CHECK(file != NULL); + AccountId_descriptor_ = file->message_type(0); + static const int AccountId_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountId, id_), + }; + AccountId_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AccountId_descriptor_, + AccountId::default_instance_, + AccountId_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountId, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountId, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AccountId)); + AccountLicense_descriptor_ = file->message_type(1); + static const int AccountLicense_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLicense, id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLicense, expires_), + }; + AccountLicense_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AccountLicense_descriptor_, + AccountLicense::default_instance_, + AccountLicense_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLicense, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLicense, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AccountLicense)); + AccountCredential_descriptor_ = file->message_type(2); + static const int AccountCredential_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountCredential, id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountCredential, data_), + }; + AccountCredential_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AccountCredential_descriptor_, + AccountCredential::default_instance_, + AccountCredential_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountCredential, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountCredential, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AccountCredential)); + AccountBlob_descriptor_ = file->message_type(3); + static const int AccountBlob_offsets_[20] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, region_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, email_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, flags_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, secure_release_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, whitelist_start_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, whitelist_end_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, full_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, licenses_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, credentials_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, account_links_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, battle_tag_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, default_currency_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, legal_region_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, legal_locale_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, cache_expiration_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, parental_control_info_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, country_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, preferred_region_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, identity_check_status_), + }; + AccountBlob_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AccountBlob_descriptor_, + AccountBlob::default_instance_, + AccountBlob_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AccountBlob)); + AccountBlobList_descriptor_ = file->message_type(4); + static const int AccountBlobList_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlobList, blob_), + }; + AccountBlobList_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AccountBlobList_descriptor_, + AccountBlobList::default_instance_, + AccountBlobList_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlobList, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlobList, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AccountBlobList)); + GameAccountHandle_descriptor_ = file->message_type(5); + static const int GameAccountHandle_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountHandle, id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountHandle, program_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountHandle, region_), + }; + GameAccountHandle_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GameAccountHandle_descriptor_, + GameAccountHandle::default_instance_, + GameAccountHandle_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountHandle, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountHandle, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GameAccountHandle)); + GameAccountLink_descriptor_ = file->message_type(6); + static const int GameAccountLink_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountLink, game_account_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountLink, name_), + }; + GameAccountLink_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GameAccountLink_descriptor_, + GameAccountLink::default_instance_, + GameAccountLink_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountLink, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountLink, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GameAccountLink)); + GameAccountBlob_descriptor_ = file->message_type(7); + static const int GameAccountBlob_offsets_[16] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, game_account_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, realm_permissions_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, status_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, flags_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, billing_flags_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, cache_expiration_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, subscription_expiration_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, units_remaining_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, status_expiration_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, box_level_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, box_level_expiration_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, licenses_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, raf_account_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, raf_info_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, raf_expiration_), + }; + GameAccountBlob_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GameAccountBlob_descriptor_, + GameAccountBlob::default_instance_, + GameAccountBlob_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GameAccountBlob)); + GameAccountBlobList_descriptor_ = file->message_type(8); + static const int GameAccountBlobList_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlobList, blob_), + }; + GameAccountBlobList_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GameAccountBlobList_descriptor_, + GameAccountBlobList::default_instance_, + GameAccountBlobList_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlobList, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlobList, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GameAccountBlobList)); + AccountReference_descriptor_ = file->message_type(9); + static const int AccountReference_offsets_[5] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountReference, id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountReference, email_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountReference, handle_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountReference, battle_tag_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountReference, region_), + }; + AccountReference_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AccountReference_descriptor_, + AccountReference::default_instance_, + AccountReference_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountReference, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountReference, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AccountReference)); + Identity_descriptor_ = file->message_type(10); + static const int Identity_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Identity, account_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Identity, game_account_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Identity, process_), + }; + Identity_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Identity_descriptor_, + Identity::default_instance_, + Identity_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Identity, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Identity, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Identity)); + ProgramTag_descriptor_ = file->message_type(11); + static const int ProgramTag_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProgramTag, program_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProgramTag, tag_), + }; + ProgramTag_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ProgramTag_descriptor_, + ProgramTag::default_instance_, + ProgramTag_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProgramTag, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProgramTag, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ProgramTag)); + RegionTag_descriptor_ = file->message_type(12); + static const int RegionTag_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RegionTag, region_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RegionTag, tag_), + }; + RegionTag_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + RegionTag_descriptor_, + RegionTag::default_instance_, + RegionTag_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RegionTag, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RegionTag, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(RegionTag)); + AccountFieldTags_descriptor_ = file->message_type(13); + static const int AccountFieldTags_offsets_[6] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldTags, account_level_info_tag_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldTags, privacy_info_tag_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldTags, parental_control_info_tag_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldTags, game_level_info_tags_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldTags, game_status_tags_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldTags, game_account_tags_), + }; + AccountFieldTags_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AccountFieldTags_descriptor_, + AccountFieldTags::default_instance_, + AccountFieldTags_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldTags, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldTags, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AccountFieldTags)); + GameAccountFieldTags_descriptor_ = file->message_type(14); + static const int GameAccountFieldTags_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldTags, game_level_info_tag_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldTags, game_time_info_tag_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldTags, game_status_tag_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldTags, raf_info_tag_), + }; + GameAccountFieldTags_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GameAccountFieldTags_descriptor_, + GameAccountFieldTags::default_instance_, + GameAccountFieldTags_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldTags, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldTags, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GameAccountFieldTags)); + AccountFieldOptions_descriptor_ = file->message_type(15); + static const int AccountFieldOptions_offsets_[7] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldOptions, all_fields_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldOptions, field_account_level_info_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldOptions, field_privacy_info_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldOptions, field_parental_control_info_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldOptions, field_game_level_info_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldOptions, field_game_status_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldOptions, field_game_accounts_), + }; + AccountFieldOptions_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AccountFieldOptions_descriptor_, + AccountFieldOptions::default_instance_, + AccountFieldOptions_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldOptions, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldOptions, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AccountFieldOptions)); + GameAccountFieldOptions_descriptor_ = file->message_type(16); + static const int GameAccountFieldOptions_offsets_[5] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldOptions, all_fields_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldOptions, field_game_level_info_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldOptions, field_game_time_info_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldOptions, field_game_status_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldOptions, field_raf_info_), + }; + GameAccountFieldOptions_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GameAccountFieldOptions_descriptor_, + GameAccountFieldOptions::default_instance_, + GameAccountFieldOptions_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldOptions, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldOptions, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GameAccountFieldOptions)); + SubscriberReference_descriptor_ = file->message_type(17); + static const int SubscriberReference_offsets_[7] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberReference, object_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberReference, entity_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberReference, account_options_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberReference, account_tags_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberReference, game_account_options_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberReference, game_account_tags_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberReference, subscriber_id_), + }; + SubscriberReference_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + SubscriberReference_descriptor_, + SubscriberReference::default_instance_, + SubscriberReference_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberReference, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberReference, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(SubscriberReference)); + AccountLevelInfo_descriptor_ = file->message_type(18); + static const int AccountLevelInfo_offsets_[11] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, licenses_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, default_currency_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, country_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, preferred_region_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, full_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, battle_tag_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, muted_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, manual_review_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, account_paid_any_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, identity_check_status_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, email_), + }; + AccountLevelInfo_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AccountLevelInfo_descriptor_, + AccountLevelInfo::default_instance_, + AccountLevelInfo_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AccountLevelInfo)); + PrivacyInfo_descriptor_ = file->message_type(19); + static const int PrivacyInfo_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrivacyInfo, is_using_rid_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrivacyInfo, is_real_id_visible_for_view_friends_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrivacyInfo, is_hidden_from_friend_finder_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrivacyInfo, game_info_privacy_), + }; + PrivacyInfo_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + PrivacyInfo_descriptor_, + PrivacyInfo::default_instance_, + PrivacyInfo_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrivacyInfo, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrivacyInfo, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(PrivacyInfo)); + PrivacyInfo_GameInfoPrivacy_descriptor_ = PrivacyInfo_descriptor_->enum_type(0); + ParentalControlInfo_descriptor_ = file->message_type(20); + static const int ParentalControlInfo_offsets_[6] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParentalControlInfo, timezone_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParentalControlInfo, minutes_per_day_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParentalControlInfo, minutes_per_week_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParentalControlInfo, can_receive_voice_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParentalControlInfo, can_send_voice_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParentalControlInfo, play_schedule_), + }; + ParentalControlInfo_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ParentalControlInfo_descriptor_, + ParentalControlInfo::default_instance_, + ParentalControlInfo_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParentalControlInfo, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParentalControlInfo, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ParentalControlInfo)); + GameLevelInfo_descriptor_ = file->message_type(21); + static const int GameLevelInfo_offsets_[8] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameLevelInfo, is_trial_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameLevelInfo, is_lifetime_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameLevelInfo, is_restricted_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameLevelInfo, is_beta_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameLevelInfo, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameLevelInfo, program_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameLevelInfo, licenses_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameLevelInfo, realm_permissions_), + }; + GameLevelInfo_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GameLevelInfo_descriptor_, + GameLevelInfo::default_instance_, + GameLevelInfo_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameLevelInfo, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameLevelInfo, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GameLevelInfo)); + GameTimeInfo_descriptor_ = file->message_type(22); + static const int GameTimeInfo_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeInfo, is_unlimited_play_time_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeInfo, play_time_expires_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeInfo, is_subscription_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeInfo, is_recurring_subscription_), + }; + GameTimeInfo_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GameTimeInfo_descriptor_, + GameTimeInfo::default_instance_, + GameTimeInfo_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeInfo, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeInfo, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GameTimeInfo)); + GameTimeRemainingInfo_descriptor_ = file->message_type(23); + static const int GameTimeRemainingInfo_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeRemainingInfo, minutes_remaining_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeRemainingInfo, parental_daily_minutes_remaining_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeRemainingInfo, parental_weekly_minutes_remaining_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeRemainingInfo, seconds_remaining_until_kick_), + }; + GameTimeRemainingInfo_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GameTimeRemainingInfo_descriptor_, + GameTimeRemainingInfo::default_instance_, + GameTimeRemainingInfo_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeRemainingInfo, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeRemainingInfo, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GameTimeRemainingInfo)); + GameStatus_descriptor_ = file->message_type(24); + static const int GameStatus_offsets_[6] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameStatus, is_suspended_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameStatus, is_banned_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameStatus, suspension_expires_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameStatus, program_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameStatus, is_locked_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameStatus, is_bam_unlockable_), + }; + GameStatus_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GameStatus_descriptor_, + GameStatus::default_instance_, + GameStatus_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameStatus, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameStatus, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GameStatus)); + RAFInfo_descriptor_ = file->message_type(25); + static const int RAFInfo_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RAFInfo, raf_info_), + }; + RAFInfo_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + RAFInfo_descriptor_, + RAFInfo::default_instance_, + RAFInfo_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RAFInfo, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RAFInfo, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(RAFInfo)); + GameSessionInfo_descriptor_ = file->message_type(26); + static const int GameSessionInfo_offsets_[6] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionInfo, start_time_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionInfo, location_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionInfo, has_benefactor_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionInfo, is_using_igr_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionInfo, parental_controls_active_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionInfo, start_time_sec_), + }; + GameSessionInfo_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GameSessionInfo_descriptor_, + GameSessionInfo::default_instance_, + GameSessionInfo_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionInfo, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionInfo, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GameSessionInfo)); + GameSessionUpdateInfo_descriptor_ = file->message_type(27); + static const int GameSessionUpdateInfo_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionUpdateInfo, cais_), + }; + GameSessionUpdateInfo_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GameSessionUpdateInfo_descriptor_, + GameSessionUpdateInfo::default_instance_, + GameSessionUpdateInfo_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionUpdateInfo, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionUpdateInfo, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GameSessionUpdateInfo)); + GameSessionLocation_descriptor_ = file->message_type(28); + static const int GameSessionLocation_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionLocation, ip_address_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionLocation, country_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionLocation, city_), + }; + GameSessionLocation_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GameSessionLocation_descriptor_, + GameSessionLocation::default_instance_, + GameSessionLocation_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionLocation, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionLocation, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GameSessionLocation)); + CAIS_descriptor_ = file->message_type(29); + static const int CAIS_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CAIS, played_minutes_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CAIS, rested_minutes_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CAIS, last_heard_time_), + }; + CAIS_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + CAIS_descriptor_, + CAIS::default_instance_, + CAIS_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CAIS, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CAIS, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(CAIS)); + GameAccountList_descriptor_ = file->message_type(30); + static const int GameAccountList_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountList, region_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountList, handle_), + }; + GameAccountList_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GameAccountList_descriptor_, + GameAccountList::default_instance_, + GameAccountList_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountList, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountList, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GameAccountList)); + AccountState_descriptor_ = file->message_type(31); + static const int AccountState_offsets_[6] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountState, account_level_info_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountState, privacy_info_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountState, parental_control_info_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountState, game_level_info_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountState, game_status_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountState, game_accounts_), + }; + AccountState_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AccountState_descriptor_, + AccountState::default_instance_, + AccountState_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountState, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountState, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AccountState)); + AccountStateTagged_descriptor_ = file->message_type(32); + static const int AccountStateTagged_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountStateTagged, account_state_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountStateTagged, account_tags_), + }; + AccountStateTagged_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AccountStateTagged_descriptor_, + AccountStateTagged::default_instance_, + AccountStateTagged_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountStateTagged, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountStateTagged, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AccountStateTagged)); + GameAccountState_descriptor_ = file->message_type(33); + static const int GameAccountState_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountState, game_level_info_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountState, game_time_info_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountState, game_status_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountState, raf_info_), + }; + GameAccountState_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GameAccountState_descriptor_, + GameAccountState::default_instance_, + GameAccountState_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountState, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountState, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GameAccountState)); + GameAccountStateTagged_descriptor_ = file->message_type(34); + static const int GameAccountStateTagged_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountStateTagged, game_account_state_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountStateTagged, game_account_tags_), + }; + GameAccountStateTagged_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GameAccountStateTagged_descriptor_, + GameAccountStateTagged::default_instance_, + GameAccountStateTagged_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountStateTagged, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountStateTagged, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GameAccountStateTagged)); + AuthorizedData_descriptor_ = file->message_type(35); + static const int AuthorizedData_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthorizedData, data_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthorizedData, license_), + }; + AuthorizedData_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AuthorizedData_descriptor_, + AuthorizedData::default_instance_, + AuthorizedData_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthorizedData, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthorizedData, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AuthorizedData)); + IdentityVerificationStatus_descriptor_ = file->enum_type(0); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_account_5ftypes_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AccountId_descriptor_, &AccountId::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AccountLicense_descriptor_, &AccountLicense::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AccountCredential_descriptor_, &AccountCredential::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AccountBlob_descriptor_, &AccountBlob::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AccountBlobList_descriptor_, &AccountBlobList::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GameAccountHandle_descriptor_, &GameAccountHandle::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GameAccountLink_descriptor_, &GameAccountLink::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GameAccountBlob_descriptor_, &GameAccountBlob::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GameAccountBlobList_descriptor_, &GameAccountBlobList::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AccountReference_descriptor_, &AccountReference::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Identity_descriptor_, &Identity::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ProgramTag_descriptor_, &ProgramTag::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + RegionTag_descriptor_, &RegionTag::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AccountFieldTags_descriptor_, &AccountFieldTags::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GameAccountFieldTags_descriptor_, &GameAccountFieldTags::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AccountFieldOptions_descriptor_, &AccountFieldOptions::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GameAccountFieldOptions_descriptor_, &GameAccountFieldOptions::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SubscriberReference_descriptor_, &SubscriberReference::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AccountLevelInfo_descriptor_, &AccountLevelInfo::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + PrivacyInfo_descriptor_, &PrivacyInfo::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ParentalControlInfo_descriptor_, &ParentalControlInfo::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GameLevelInfo_descriptor_, &GameLevelInfo::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GameTimeInfo_descriptor_, &GameTimeInfo::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GameTimeRemainingInfo_descriptor_, &GameTimeRemainingInfo::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GameStatus_descriptor_, &GameStatus::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + RAFInfo_descriptor_, &RAFInfo::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GameSessionInfo_descriptor_, &GameSessionInfo::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GameSessionUpdateInfo_descriptor_, &GameSessionUpdateInfo::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GameSessionLocation_descriptor_, &GameSessionLocation::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + CAIS_descriptor_, &CAIS::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GameAccountList_descriptor_, &GameAccountList::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AccountState_descriptor_, &AccountState::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AccountStateTagged_descriptor_, &AccountStateTagged::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GameAccountState_descriptor_, &GameAccountState::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GameAccountStateTagged_descriptor_, &GameAccountStateTagged::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AuthorizedData_descriptor_, &AuthorizedData::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_account_5ftypes_2eproto() { + delete AccountId::default_instance_; + delete AccountId_reflection_; + delete AccountLicense::default_instance_; + delete AccountLicense_reflection_; + delete AccountCredential::default_instance_; + delete AccountCredential_reflection_; + delete AccountBlob::default_instance_; + delete AccountBlob_reflection_; + delete AccountBlobList::default_instance_; + delete AccountBlobList_reflection_; + delete GameAccountHandle::default_instance_; + delete GameAccountHandle_reflection_; + delete GameAccountLink::default_instance_; + delete GameAccountLink_reflection_; + delete GameAccountBlob::default_instance_; + delete GameAccountBlob_reflection_; + delete GameAccountBlobList::default_instance_; + delete GameAccountBlobList_reflection_; + delete AccountReference::default_instance_; + delete AccountReference_reflection_; + delete Identity::default_instance_; + delete Identity_reflection_; + delete ProgramTag::default_instance_; + delete ProgramTag_reflection_; + delete RegionTag::default_instance_; + delete RegionTag_reflection_; + delete AccountFieldTags::default_instance_; + delete AccountFieldTags_reflection_; + delete GameAccountFieldTags::default_instance_; + delete GameAccountFieldTags_reflection_; + delete AccountFieldOptions::default_instance_; + delete AccountFieldOptions_reflection_; + delete GameAccountFieldOptions::default_instance_; + delete GameAccountFieldOptions_reflection_; + delete SubscriberReference::default_instance_; + delete SubscriberReference_reflection_; + delete AccountLevelInfo::default_instance_; + delete AccountLevelInfo_reflection_; + delete PrivacyInfo::default_instance_; + delete PrivacyInfo_reflection_; + delete ParentalControlInfo::default_instance_; + delete ParentalControlInfo_reflection_; + delete GameLevelInfo::default_instance_; + delete GameLevelInfo_reflection_; + delete GameTimeInfo::default_instance_; + delete GameTimeInfo_reflection_; + delete GameTimeRemainingInfo::default_instance_; + delete GameTimeRemainingInfo_reflection_; + delete GameStatus::default_instance_; + delete GameStatus_reflection_; + delete RAFInfo::default_instance_; + delete RAFInfo_reflection_; + delete GameSessionInfo::default_instance_; + delete GameSessionInfo_reflection_; + delete GameSessionUpdateInfo::default_instance_; + delete GameSessionUpdateInfo_reflection_; + delete GameSessionLocation::default_instance_; + delete GameSessionLocation_reflection_; + delete CAIS::default_instance_; + delete CAIS_reflection_; + delete GameAccountList::default_instance_; + delete GameAccountList_reflection_; + delete AccountState::default_instance_; + delete AccountState_reflection_; + delete AccountStateTagged::default_instance_; + delete AccountStateTagged_reflection_; + delete GameAccountState::default_instance_; + delete GameAccountState_reflection_; + delete GameAccountStateTagged::default_instance_; + delete GameAccountStateTagged_reflection_; + delete AuthorizedData::default_instance_; + delete AuthorizedData_reflection_; +} + +void protobuf_AddDesc_account_5ftypes_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\023account_types.proto\022\027bgs.protocol.acco" + "unt.v1\032\022entity_types.proto\032\017rpc_types.pr" + "oto\"\027\n\tAccountId\022\n\n\002id\030\001 \002(\007\"-\n\016AccountL" + "icense\022\n\n\002id\030\001 \002(\r\022\017\n\007expires\030\002 \001(\004\"-\n\021A" + "ccountCredential\022\n\n\002id\030\001 \002(\r\022\014\n\004data\030\002 \001" + "(\014\"\237\005\n\013AccountBlob\022\n\n\002id\030\002 \002(\007\022\016\n\006region" + "\030\003 \002(\r\022\r\n\005email\030\004 \003(\t\022\r\n\005flags\030\005 \002(\004\022\026\n\016" + "secure_release\030\006 \001(\004\022\027\n\017whitelist_start\030" + "\007 \001(\004\022\025\n\rwhitelist_end\030\010 \001(\004\022\021\n\tfull_nam" + "e\030\n \002(\t\0229\n\010licenses\030\024 \003(\0132\'.bgs.protocol" + ".account.v1.AccountLicense\022\?\n\013credential" + "s\030\025 \003(\0132*.bgs.protocol.account.v1.Accoun" + "tCredential\022\?\n\raccount_links\030\026 \003(\0132(.bgs" + ".protocol.account.v1.GameAccountLink\022\022\n\n" + "battle_tag\030\027 \001(\t\022\030\n\020default_currency\030\031 \001" + "(\007\022\024\n\014legal_region\030\032 \001(\r\022\024\n\014legal_locale" + "\030\033 \001(\007\022\030\n\020cache_expiration\030\036 \002(\004\022K\n\025pare" + "ntal_control_info\030\037 \001(\0132,.bgs.protocol.a" + "ccount.v1.ParentalControlInfo\022\017\n\007country" + "\030 \001(\t\022\030\n\020preferred_region\030! \001(\r\022R\n\025iden" + "tity_check_status\030\" \001(\01623.bgs.protocol.a" + "ccount.v1.IdentityVerificationStatus\"E\n\017" + "AccountBlobList\0222\n\004blob\030\001 \003(\0132$.bgs.prot" + "ocol.account.v1.AccountBlob\"@\n\021GameAccou" + "ntHandle\022\n\n\002id\030\001 \002(\007\022\017\n\007program\030\002 \002(\007\022\016\n" + "\006region\030\003 \002(\r\"a\n\017GameAccountLink\022@\n\014game" + "_account\030\001 \002(\0132*.bgs.protocol.account.v1" + ".GameAccountHandle\022\014\n\004name\030\002 \002(\t\"\327\003\n\017Gam" + "eAccountBlob\022@\n\014game_account\030\001 \002(\0132*.bgs" + ".protocol.account.v1.GameAccountHandle\022\016" + "\n\004name\030\002 \001(\t:\000\022\034\n\021realm_permissions\030\003 \001(" + "\r:\0010\022\016\n\006status\030\004 \002(\r\022\020\n\005flags\030\005 \001(\004:\0010\022\030" + "\n\rbilling_flags\030\006 \001(\r:\0010\022\030\n\020cache_expira" + "tion\030\007 \002(\004\022\037\n\027subscription_expiration\030\n " + "\001(\004\022\027\n\017units_remaining\030\013 \001(\r\022\031\n\021status_e" + "xpiration\030\014 \001(\004\022\021\n\tbox_level\030\r \001(\r\022\034\n\024bo" + "x_level_expiration\030\016 \001(\004\0229\n\010licenses\030\024 \003" + "(\0132\'.bgs.protocol.account.v1.AccountLice" + "nse\022\023\n\013raf_account\030\025 \001(\007\022\020\n\010raf_info\030\026 \001" + "(\014\022\026\n\016raf_expiration\030\027 \001(\004\"M\n\023GameAccoun" + "tBlobList\0226\n\004blob\030\001 \003(\0132(.bgs.protocol.a" + "ccount.v1.GameAccountBlob\"\220\001\n\020AccountRef" + "erence\022\n\n\002id\030\001 \001(\007\022\r\n\005email\030\002 \001(\t\022:\n\006han" + "dle\030\003 \001(\0132*.bgs.protocol.account.v1.Game" + "AccountHandle\022\022\n\nbattle_tag\030\004 \001(\t\022\021\n\006reg" + "ion\030\n \001(\r:\0010\"\253\001\n\010Identity\0223\n\007account\030\001 \001" + "(\0132\".bgs.protocol.account.v1.AccountId\022@" + "\n\014game_account\030\002 \001(\0132*.bgs.protocol.acco" + "unt.v1.GameAccountHandle\022(\n\007process\030\003 \001(" + "\0132\027.bgs.protocol.ProcessId\"*\n\nProgramTag" + "\022\017\n\007program\030\001 \001(\007\022\013\n\003tag\030\002 \001(\007\"(\n\tRegion" + "Tag\022\016\n\006region\030\001 \001(\007\022\013\n\003tag\030\002 \001(\007\"\260\002\n\020Acc" + "ountFieldTags\022\036\n\026account_level_info_tag\030" + "\002 \001(\007\022\030\n\020privacy_info_tag\030\003 \001(\007\022!\n\031paren" + "tal_control_info_tag\030\004 \001(\007\022A\n\024game_level" + "_info_tags\030\007 \003(\0132#.bgs.protocol.account." + "v1.ProgramTag\022=\n\020game_status_tags\030\t \003(\0132" + "#.bgs.protocol.account.v1.ProgramTag\022=\n\021" + "game_account_tags\030\013 \003(\0132\".bgs.protocol.a" + "ccount.v1.RegionTag\"~\n\024GameAccountFieldT" + "ags\022\033\n\023game_level_info_tag\030\002 \001(\007\022\032\n\022game" + "_time_info_tag\030\003 \001(\007\022\027\n\017game_status_tag\030" + "\004 \001(\007\022\024\n\014raf_info_tag\030\005 \001(\007\"\343\001\n\023AccountF" + "ieldOptions\022\022\n\nall_fields\030\001 \001(\010\022 \n\030field" + "_account_level_info\030\002 \001(\010\022\032\n\022field_priva" + "cy_info\030\003 \001(\010\022#\n\033field_parental_control_" + "info\030\004 \001(\010\022\035\n\025field_game_level_info\030\006 \001(" + "\010\022\031\n\021field_game_status\030\007 \001(\010\022\033\n\023field_ga" + "me_accounts\030\010 \001(\010\"\235\001\n\027GameAccountFieldOp" + "tions\022\022\n\nall_fields\030\001 \001(\010\022\035\n\025field_game_" + "level_info\030\002 \001(\010\022\034\n\024field_game_time_info" + "\030\003 \001(\010\022\031\n\021field_game_status\030\004 \001(\010\022\026\n\016fie" + "ld_raf_info\030\005 \001(\010\"\222\003\n\023SubscriberReferenc" + "e\022\024\n\tobject_id\030\001 \001(\004:\0010\022)\n\tentity_id\030\002 \001" + "(\0132\026.bgs.protocol.EntityId\022E\n\017account_op" + "tions\030\003 \001(\0132,.bgs.protocol.account.v1.Ac" + "countFieldOptions\022\?\n\014account_tags\030\004 \001(\0132" + ").bgs.protocol.account.v1.AccountFieldTa" + "gs\022N\n\024game_account_options\030\005 \001(\01320.bgs.p" + "rotocol.account.v1.GameAccountFieldOptio" + "ns\022H\n\021game_account_tags\030\006 \001(\0132-.bgs.prot" + "ocol.account.v1.GameAccountFieldTags\022\030\n\r" + "subscriber_id\030\007 \001(\004:\0010\"\334\002\n\020AccountLevelI" + "nfo\0229\n\010licenses\030\003 \003(\0132\'.bgs.protocol.acc" + "ount.v1.AccountLicense\022\030\n\020default_curren" + "cy\030\004 \001(\007\022\017\n\007country\030\005 \001(\t\022\030\n\020preferred_r" + "egion\030\006 \001(\r\022\021\n\tfull_name\030\007 \001(\t\022\022\n\nbattle" + "_tag\030\010 \001(\t\022\r\n\005muted\030\t \001(\010\022\025\n\rmanual_revi" + "ew\030\n \001(\010\022\030\n\020account_paid_any\030\013 \001(\010\022R\n\025id" + "entity_check_status\030\014 \001(\01623.bgs.protocol" + ".account.v1.IdentityVerificationStatus\022\r" + "\n\005email\030\r \001(\t\"\246\002\n\013PrivacyInfo\022\024\n\014is_usin" + "g_rid\030\003 \001(\010\022+\n#is_real_id_visible_for_vi" + "ew_friends\030\004 \001(\010\022$\n\034is_hidden_from_frien" + "d_finder\030\005 \001(\010\022`\n\021game_info_privacy\030\006 \001(" + "\01624.bgs.protocol.account.v1.PrivacyInfo." + "GameInfoPrivacy:\017PRIVACY_FRIENDS\"L\n\017Game" + "InfoPrivacy\022\016\n\nPRIVACY_ME\020\000\022\023\n\017PRIVACY_F" + "RIENDS\020\001\022\024\n\020PRIVACY_EVERYONE\020\002\"\244\001\n\023Paren" + "talControlInfo\022\020\n\010timezone\030\003 \001(\t\022\027\n\017minu" + "tes_per_day\030\004 \001(\r\022\030\n\020minutes_per_week\030\005 " + "\001(\r\022\031\n\021can_receive_voice\030\006 \001(\010\022\026\n\016can_se" + "nd_voice\030\007 \001(\010\022\025\n\rplay_schedule\030\010 \003(\010\"\323\001" + "\n\rGameLevelInfo\022\020\n\010is_trial\030\004 \001(\010\022\023\n\013is_" + "lifetime\030\005 \001(\010\022\025\n\ris_restricted\030\006 \001(\010\022\017\n" + "\007is_beta\030\007 \001(\010\022\014\n\004name\030\010 \001(\t\022\017\n\007program\030" + "\t \001(\007\0229\n\010licenses\030\n \003(\0132\'.bgs.protocol.a" + "ccount.v1.AccountLicense\022\031\n\021realm_permis" + "sions\030\013 \001(\r\"\205\001\n\014GameTimeInfo\022\036\n\026is_unlim" + "ited_play_time\030\003 \001(\010\022\031\n\021play_time_expire" + "s\030\005 \001(\004\022\027\n\017is_subscription\030\006 \001(\010\022!\n\031is_r" + "ecurring_subscription\030\007 \001(\010\"\255\001\n\025GameTime" + "RemainingInfo\022\031\n\021minutes_remaining\030\001 \001(\r" + "\022(\n parental_daily_minutes_remaining\030\002 \001" + "(\r\022)\n!parental_weekly_minutes_remaining\030" + "\003 \001(\r\022$\n\034seconds_remaining_until_kick\030\004 " + "\001(\r\"\220\001\n\nGameStatus\022\024\n\014is_suspended\030\004 \001(\010" + "\022\021\n\tis_banned\030\005 \001(\010\022\032\n\022suspension_expire" + "s\030\006 \001(\004\022\017\n\007program\030\007 \001(\007\022\021\n\tis_locked\030\010 " + "\001(\010\022\031\n\021is_bam_unlockable\030\t \001(\010\"\033\n\007RAFInf" + "o\022\020\n\010raf_info\030\001 \001(\014\"\321\001\n\017GameSessionInfo\022" + "\026\n\nstart_time\030\003 \001(\rB\002\030\001\022>\n\010location\030\004 \001(" + "\0132,.bgs.protocol.account.v1.GameSessionL" + "ocation\022\026\n\016has_benefactor\030\005 \001(\010\022\024\n\014is_us" + "ing_igr\030\006 \001(\010\022 \n\030parental_controls_activ" + "e\030\007 \001(\010\022\026\n\016start_time_sec\030\010 \001(\004\"D\n\025GameS" + "essionUpdateInfo\022+\n\004cais\030\010 \001(\0132\035.bgs.pro" + "tocol.account.v1.CAIS\"H\n\023GameSessionLoca" + "tion\022\022\n\nip_address\030\001 \001(\t\022\017\n\007country\030\002 \001(" + "\r\022\014\n\004city\030\003 \001(\t\"O\n\004CAIS\022\026\n\016played_minute" + "s\030\001 \001(\r\022\026\n\016rested_minutes\030\002 \001(\r\022\027\n\017last_" + "heard_time\030\003 \001(\004\"]\n\017GameAccountList\022\016\n\006r" + "egion\030\003 \001(\r\022:\n\006handle\030\004 \003(\0132*.bgs.protoc" + "ol.account.v1.GameAccountHandle\"\232\003\n\014Acco" + "untState\022E\n\022account_level_info\030\001 \001(\0132).b" + "gs.protocol.account.v1.AccountLevelInfo\022" + ":\n\014privacy_info\030\002 \001(\0132$.bgs.protocol.acc" + "ount.v1.PrivacyInfo\022K\n\025parental_control_" + "info\030\003 \001(\0132,.bgs.protocol.account.v1.Par" + "entalControlInfo\022\?\n\017game_level_info\030\005 \003(" + "\0132&.bgs.protocol.account.v1.GameLevelInf" + "o\0228\n\013game_status\030\006 \003(\0132#.bgs.protocol.ac" + "count.v1.GameStatus\022\?\n\rgame_accounts\030\007 \003" + "(\0132(.bgs.protocol.account.v1.GameAccount" + "List\"\223\001\n\022AccountStateTagged\022<\n\raccount_s" + "tate\030\001 \001(\0132%.bgs.protocol.account.v1.Acc" + "ountState\022\?\n\014account_tags\030\002 \001(\0132).bgs.pr" + "otocol.account.v1.AccountFieldTags\"\200\002\n\020G" + "ameAccountState\022\?\n\017game_level_info\030\001 \001(\013" + "2&.bgs.protocol.account.v1.GameLevelInfo" + "\022=\n\016game_time_info\030\002 \001(\0132%.bgs.protocol." + "account.v1.GameTimeInfo\0228\n\013game_status\030\003" + " \001(\0132#.bgs.protocol.account.v1.GameStatu" + "s\0222\n\010raf_info\030\004 \001(\0132 .bgs.protocol.accou" + "nt.v1.RAFInfo\"\251\001\n\026GameAccountStateTagged" + "\022E\n\022game_account_state\030\001 \001(\0132).bgs.proto" + "col.account.v1.GameAccountState\022H\n\021game_" + "account_tags\030\002 \001(\0132-.bgs.protocol.accoun" + "t.v1.GameAccountFieldTags\"/\n\016AuthorizedD" + "ata\022\014\n\004data\030\001 \001(\t\022\017\n\007license\030\002 \003(\r*\216\001\n\032I" + "dentityVerificationStatus\022\021\n\rIDENT_NO_DA" + "TA\020\000\022\021\n\rIDENT_PENDING\020\001\022\020\n\014IDENT_FAILED\020" + "\004\022\021\n\rIDENT_SUCCESS\020\005\022\022\n\016IDENT_SUCC_MNL\020\006" + "\022\021\n\rIDENT_UNKNOWN\020\007B\002H\001", 6543); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "account_types.proto", &protobuf_RegisterTypes); + AccountId::default_instance_ = new AccountId(); + AccountLicense::default_instance_ = new AccountLicense(); + AccountCredential::default_instance_ = new AccountCredential(); + AccountBlob::default_instance_ = new AccountBlob(); + AccountBlobList::default_instance_ = new AccountBlobList(); + GameAccountHandle::default_instance_ = new GameAccountHandle(); + GameAccountLink::default_instance_ = new GameAccountLink(); + GameAccountBlob::default_instance_ = new GameAccountBlob(); + GameAccountBlobList::default_instance_ = new GameAccountBlobList(); + AccountReference::default_instance_ = new AccountReference(); + Identity::default_instance_ = new Identity(); + ProgramTag::default_instance_ = new ProgramTag(); + RegionTag::default_instance_ = new RegionTag(); + AccountFieldTags::default_instance_ = new AccountFieldTags(); + GameAccountFieldTags::default_instance_ = new GameAccountFieldTags(); + AccountFieldOptions::default_instance_ = new AccountFieldOptions(); + GameAccountFieldOptions::default_instance_ = new GameAccountFieldOptions(); + SubscriberReference::default_instance_ = new SubscriberReference(); + AccountLevelInfo::default_instance_ = new AccountLevelInfo(); + PrivacyInfo::default_instance_ = new PrivacyInfo(); + ParentalControlInfo::default_instance_ = new ParentalControlInfo(); + GameLevelInfo::default_instance_ = new GameLevelInfo(); + GameTimeInfo::default_instance_ = new GameTimeInfo(); + GameTimeRemainingInfo::default_instance_ = new GameTimeRemainingInfo(); + GameStatus::default_instance_ = new GameStatus(); + RAFInfo::default_instance_ = new RAFInfo(); + GameSessionInfo::default_instance_ = new GameSessionInfo(); + GameSessionUpdateInfo::default_instance_ = new GameSessionUpdateInfo(); + GameSessionLocation::default_instance_ = new GameSessionLocation(); + CAIS::default_instance_ = new CAIS(); + GameAccountList::default_instance_ = new GameAccountList(); + AccountState::default_instance_ = new AccountState(); + AccountStateTagged::default_instance_ = new AccountStateTagged(); + GameAccountState::default_instance_ = new GameAccountState(); + GameAccountStateTagged::default_instance_ = new GameAccountStateTagged(); + AuthorizedData::default_instance_ = new AuthorizedData(); + AccountId::default_instance_->InitAsDefaultInstance(); + AccountLicense::default_instance_->InitAsDefaultInstance(); + AccountCredential::default_instance_->InitAsDefaultInstance(); + AccountBlob::default_instance_->InitAsDefaultInstance(); + AccountBlobList::default_instance_->InitAsDefaultInstance(); + GameAccountHandle::default_instance_->InitAsDefaultInstance(); + GameAccountLink::default_instance_->InitAsDefaultInstance(); + GameAccountBlob::default_instance_->InitAsDefaultInstance(); + GameAccountBlobList::default_instance_->InitAsDefaultInstance(); + AccountReference::default_instance_->InitAsDefaultInstance(); + Identity::default_instance_->InitAsDefaultInstance(); + ProgramTag::default_instance_->InitAsDefaultInstance(); + RegionTag::default_instance_->InitAsDefaultInstance(); + AccountFieldTags::default_instance_->InitAsDefaultInstance(); + GameAccountFieldTags::default_instance_->InitAsDefaultInstance(); + AccountFieldOptions::default_instance_->InitAsDefaultInstance(); + GameAccountFieldOptions::default_instance_->InitAsDefaultInstance(); + SubscriberReference::default_instance_->InitAsDefaultInstance(); + AccountLevelInfo::default_instance_->InitAsDefaultInstance(); + PrivacyInfo::default_instance_->InitAsDefaultInstance(); + ParentalControlInfo::default_instance_->InitAsDefaultInstance(); + GameLevelInfo::default_instance_->InitAsDefaultInstance(); + GameTimeInfo::default_instance_->InitAsDefaultInstance(); + GameTimeRemainingInfo::default_instance_->InitAsDefaultInstance(); + GameStatus::default_instance_->InitAsDefaultInstance(); + RAFInfo::default_instance_->InitAsDefaultInstance(); + GameSessionInfo::default_instance_->InitAsDefaultInstance(); + GameSessionUpdateInfo::default_instance_->InitAsDefaultInstance(); + GameSessionLocation::default_instance_->InitAsDefaultInstance(); + CAIS::default_instance_->InitAsDefaultInstance(); + GameAccountList::default_instance_->InitAsDefaultInstance(); + AccountState::default_instance_->InitAsDefaultInstance(); + AccountStateTagged::default_instance_->InitAsDefaultInstance(); + GameAccountState::default_instance_->InitAsDefaultInstance(); + GameAccountStateTagged::default_instance_->InitAsDefaultInstance(); + AuthorizedData::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_account_5ftypes_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_account_5ftypes_2eproto { + StaticDescriptorInitializer_account_5ftypes_2eproto() { + protobuf_AddDesc_account_5ftypes_2eproto(); + } +} static_descriptor_initializer_account_5ftypes_2eproto_; +const ::google::protobuf::EnumDescriptor* IdentityVerificationStatus_descriptor() { + protobuf_AssignDescriptorsOnce(); + return IdentityVerificationStatus_descriptor_; +} +bool IdentityVerificationStatus_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 4: + case 5: + case 6: + case 7: + return true; + default: + return false; + } +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AccountId::kIdFieldNumber; +#endif // !_MSC_VER + +AccountId::AccountId() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountId) +} + +void AccountId::InitAsDefaultInstance() { +} + +AccountId::AccountId(const AccountId& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountId) +} + +void AccountId::SharedCtor() { + _cached_size_ = 0; + id_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AccountId::~AccountId() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountId) + SharedDtor(); +} + +void AccountId::SharedDtor() { + if (this != default_instance_) { + } +} + +void AccountId::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AccountId::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AccountId_descriptor_; +} + +const AccountId& AccountId::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +AccountId* AccountId::default_instance_ = NULL; + +AccountId* AccountId::New() const { + return new AccountId; +} + +void AccountId::Clear() { + id_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AccountId::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountId) + 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)) { + // required fixed32 id = 1; + case 1: { + if (tag == 13) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &id_))); + set_has_id(); + } 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:bgs.protocol.account.v1.AccountId) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountId) + return false; +#undef DO_ +} + +void AccountId::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountId) + // required fixed32 id = 1; + if (has_id()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountId) +} + +::google::protobuf::uint8* AccountId::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountId) + // required fixed32 id = 1; + if (has_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountId) + return target; +} + +int AccountId::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed32 id = 1; + if (has_id()) { + 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 AccountId::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AccountId* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AccountId::MergeFrom(const AccountId& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_id()) { + set_id(from.id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AccountId::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AccountId::CopyFrom(const AccountId& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AccountId::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void AccountId::Swap(AccountId* other) { + if (other != this) { + std::swap(id_, other->id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata AccountId::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AccountId_descriptor_; + metadata.reflection = AccountId_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AccountLicense::kIdFieldNumber; +const int AccountLicense::kExpiresFieldNumber; +#endif // !_MSC_VER + +AccountLicense::AccountLicense() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountLicense) +} + +void AccountLicense::InitAsDefaultInstance() { +} + +AccountLicense::AccountLicense(const AccountLicense& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountLicense) +} + +void AccountLicense::SharedCtor() { + _cached_size_ = 0; + id_ = 0u; + expires_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AccountLicense::~AccountLicense() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountLicense) + SharedDtor(); +} + +void AccountLicense::SharedDtor() { + if (this != default_instance_) { + } +} + +void AccountLicense::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AccountLicense::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AccountLicense_descriptor_; +} + +const AccountLicense& AccountLicense::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +AccountLicense* AccountLicense::default_instance_ = NULL; + +AccountLicense* AccountLicense::New() const { + return new AccountLicense; +} + +void AccountLicense::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(expires_, id_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AccountLicense::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountLicense) + 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)) { + // required uint32 id = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &id_))); + set_has_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_expires; + break; + } + + // optional uint64 expires = 2; + case 2: { + if (tag == 16) { + parse_expires: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &expires_))); + set_has_expires(); + } 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:bgs.protocol.account.v1.AccountLicense) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountLicense) + return false; +#undef DO_ +} + +void AccountLicense::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountLicense) + // required uint32 id = 1; + if (has_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->id(), output); + } + + // optional uint64 expires = 2; + if (has_expires()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->expires(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountLicense) +} + +::google::protobuf::uint8* AccountLicense::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountLicense) + // required uint32 id = 1; + if (has_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->id(), target); + } + + // optional uint64 expires = 2; + if (has_expires()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->expires(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountLicense) + return target; +} + +int AccountLicense::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required uint32 id = 1; + if (has_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->id()); + } + + // optional uint64 expires = 2; + if (has_expires()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->expires()); + } + + } + 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 AccountLicense::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AccountLicense* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AccountLicense::MergeFrom(const AccountLicense& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_id()) { + set_id(from.id()); + } + if (from.has_expires()) { + set_expires(from.expires()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AccountLicense::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AccountLicense::CopyFrom(const AccountLicense& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AccountLicense::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void AccountLicense::Swap(AccountLicense* other) { + if (other != this) { + std::swap(id_, other->id_); + std::swap(expires_, other->expires_); + 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 AccountLicense::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AccountLicense_descriptor_; + metadata.reflection = AccountLicense_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AccountCredential::kIdFieldNumber; +const int AccountCredential::kDataFieldNumber; +#endif // !_MSC_VER + +AccountCredential::AccountCredential() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountCredential) +} + +void AccountCredential::InitAsDefaultInstance() { +} + +AccountCredential::AccountCredential(const AccountCredential& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountCredential) +} + +void AccountCredential::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + id_ = 0u; + data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AccountCredential::~AccountCredential() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountCredential) + SharedDtor(); +} + +void AccountCredential::SharedDtor() { + if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete data_; + } + if (this != default_instance_) { + } +} + +void AccountCredential::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AccountCredential::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AccountCredential_descriptor_; +} + +const AccountCredential& AccountCredential::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +AccountCredential* AccountCredential::default_instance_ = NULL; + +AccountCredential* AccountCredential::New() const { + return new AccountCredential; +} + +void AccountCredential::Clear() { + if (_has_bits_[0 / 32] & 3) { + id_ = 0u; + if (has_data()) { + if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AccountCredential::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountCredential) + 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)) { + // required uint32 id = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &id_))); + set_has_id(); + } 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:bgs.protocol.account.v1.AccountCredential) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountCredential) + return false; +#undef DO_ +} + +void AccountCredential::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountCredential) + // required uint32 id = 1; + if (has_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->id(), 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:bgs.protocol.account.v1.AccountCredential) +} + +::google::protobuf::uint8* AccountCredential::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountCredential) + // required uint32 id = 1; + if (has_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->id(), 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:bgs.protocol.account.v1.AccountCredential) + return target; +} + +int AccountCredential::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required uint32 id = 1; + if (has_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->id()); + } + + // 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 AccountCredential::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AccountCredential* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AccountCredential::MergeFrom(const AccountCredential& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_id()) { + set_id(from.id()); + } + if (from.has_data()) { + set_data(from.data()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AccountCredential::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AccountCredential::CopyFrom(const AccountCredential& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AccountCredential::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void AccountCredential::Swap(AccountCredential* other) { + if (other != this) { + std::swap(id_, other->id_); + 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 AccountCredential::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AccountCredential_descriptor_; + metadata.reflection = AccountCredential_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AccountBlob::kIdFieldNumber; +const int AccountBlob::kRegionFieldNumber; +const int AccountBlob::kEmailFieldNumber; +const int AccountBlob::kFlagsFieldNumber; +const int AccountBlob::kSecureReleaseFieldNumber; +const int AccountBlob::kWhitelistStartFieldNumber; +const int AccountBlob::kWhitelistEndFieldNumber; +const int AccountBlob::kFullNameFieldNumber; +const int AccountBlob::kLicensesFieldNumber; +const int AccountBlob::kCredentialsFieldNumber; +const int AccountBlob::kAccountLinksFieldNumber; +const int AccountBlob::kBattleTagFieldNumber; +const int AccountBlob::kDefaultCurrencyFieldNumber; +const int AccountBlob::kLegalRegionFieldNumber; +const int AccountBlob::kLegalLocaleFieldNumber; +const int AccountBlob::kCacheExpirationFieldNumber; +const int AccountBlob::kParentalControlInfoFieldNumber; +const int AccountBlob::kCountryFieldNumber; +const int AccountBlob::kPreferredRegionFieldNumber; +const int AccountBlob::kIdentityCheckStatusFieldNumber; +#endif // !_MSC_VER + +AccountBlob::AccountBlob() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountBlob) +} + +void AccountBlob::InitAsDefaultInstance() { + parental_control_info_ = const_cast< ::bgs::protocol::account::v1::ParentalControlInfo*>(&::bgs::protocol::account::v1::ParentalControlInfo::default_instance()); +} + +AccountBlob::AccountBlob(const AccountBlob& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountBlob) +} + +void AccountBlob::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + id_ = 0u; + region_ = 0u; + flags_ = GOOGLE_ULONGLONG(0); + secure_release_ = GOOGLE_ULONGLONG(0); + whitelist_start_ = GOOGLE_ULONGLONG(0); + whitelist_end_ = GOOGLE_ULONGLONG(0); + full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + default_currency_ = 0u; + legal_region_ = 0u; + legal_locale_ = 0u; + cache_expiration_ = GOOGLE_ULONGLONG(0); + parental_control_info_ = NULL; + country_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + preferred_region_ = 0u; + identity_check_status_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AccountBlob::~AccountBlob() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountBlob) + SharedDtor(); +} + +void AccountBlob::SharedDtor() { + if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete full_name_; + } + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete battle_tag_; + } + if (country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete country_; + } + if (this != default_instance_) { + delete parental_control_info_; + } +} + +void AccountBlob::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AccountBlob::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AccountBlob_descriptor_; +} + +const AccountBlob& AccountBlob::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +AccountBlob* AccountBlob::default_instance_ = NULL; + +AccountBlob* AccountBlob::New() const { + return new AccountBlob; +} + +void AccountBlob::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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] & 251) { + ZR_(id_, region_); + ZR_(flags_, whitelist_end_); + if (has_full_name()) { + if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + full_name_->clear(); + } + } + } + if (_has_bits_[8 / 32] & 63488) { + ZR_(default_currency_, cache_expiration_); + if (has_battle_tag()) { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_->clear(); + } + } + legal_locale_ = 0u; + } + if (_has_bits_[16 / 32] & 983040) { + if (has_parental_control_info()) { + if (parental_control_info_ != NULL) parental_control_info_->::bgs::protocol::account::v1::ParentalControlInfo::Clear(); + } + if (has_country()) { + if (country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + country_->clear(); + } + } + preferred_region_ = 0u; + identity_check_status_ = 0; + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + email_.Clear(); + licenses_.Clear(); + credentials_.Clear(); + account_links_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AccountBlob::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountBlob) + 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)) { + // required fixed32 id = 2; + case 2: { + if (tag == 21) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &id_))); + set_has_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_region; + break; + } + + // required uint32 region = 3; + case 3: { + if (tag == 24) { + parse_region: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, ®ion_))); + set_has_region(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_email; + break; + } + + // repeated string email = 4; + case 4: { + if (tag == 34) { + parse_email: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_email())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->email(this->email_size() - 1).data(), + this->email(this->email_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE, + "email"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_email; + if (input->ExpectTag(40)) goto parse_flags; + break; + } + + // required uint64 flags = 5; + case 5: { + if (tag == 40) { + parse_flags: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &flags_))); + set_has_flags(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_secure_release; + break; + } + + // optional uint64 secure_release = 6; + case 6: { + if (tag == 48) { + parse_secure_release: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &secure_release_))); + set_has_secure_release(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(56)) goto parse_whitelist_start; + break; + } + + // optional uint64 whitelist_start = 7; + case 7: { + if (tag == 56) { + parse_whitelist_start: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &whitelist_start_))); + set_has_whitelist_start(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(64)) goto parse_whitelist_end; + break; + } + + // optional uint64 whitelist_end = 8; + case 8: { + if (tag == 64) { + parse_whitelist_end: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &whitelist_end_))); + set_has_whitelist_end(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(82)) goto parse_full_name; + break; + } + + // required string full_name = 10; + case 10: { + if (tag == 82) { + parse_full_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_full_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->full_name().data(), this->full_name().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "full_name"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(162)) goto parse_licenses; + break; + } + + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20; + case 20: { + if (tag == 162) { + parse_licenses: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_licenses())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(162)) goto parse_licenses; + if (input->ExpectTag(170)) goto parse_credentials; + break; + } + + // repeated .bgs.protocol.account.v1.AccountCredential credentials = 21; + case 21: { + if (tag == 170) { + parse_credentials: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_credentials())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(170)) goto parse_credentials; + if (input->ExpectTag(178)) goto parse_account_links; + break; + } + + // repeated .bgs.protocol.account.v1.GameAccountLink account_links = 22; + case 22: { + if (tag == 178) { + parse_account_links: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_account_links())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(178)) goto parse_account_links; + if (input->ExpectTag(186)) goto parse_battle_tag; + break; + } + + // optional string battle_tag = 23; + case 23: { + if (tag == 186) { + parse_battle_tag: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_battle_tag())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->battle_tag().data(), this->battle_tag().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "battle_tag"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(205)) goto parse_default_currency; + break; + } + + // optional fixed32 default_currency = 25; + case 25: { + if (tag == 205) { + parse_default_currency: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &default_currency_))); + set_has_default_currency(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(208)) goto parse_legal_region; + break; + } + + // optional uint32 legal_region = 26; + case 26: { + if (tag == 208) { + parse_legal_region: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &legal_region_))); + set_has_legal_region(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(221)) goto parse_legal_locale; + break; + } + + // optional fixed32 legal_locale = 27; + case 27: { + if (tag == 221) { + parse_legal_locale: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &legal_locale_))); + set_has_legal_locale(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(240)) goto parse_cache_expiration; + break; + } + + // required uint64 cache_expiration = 30; + case 30: { + if (tag == 240) { + parse_cache_expiration: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &cache_expiration_))); + set_has_cache_expiration(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(250)) goto parse_parental_control_info; + break; + } + + // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 31; + case 31: { + if (tag == 250) { + parse_parental_control_info: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_parental_control_info())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(258)) goto parse_country; + break; + } + + // optional string country = 32; + case 32: { + if (tag == 258) { + parse_country: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_country())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->country().data(), this->country().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "country"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(264)) goto parse_preferred_region; + break; + } + + // optional uint32 preferred_region = 33; + case 33: { + if (tag == 264) { + parse_preferred_region: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &preferred_region_))); + set_has_preferred_region(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(272)) goto parse_identity_check_status; + break; + } + + // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 34; + case 34: { + if (tag == 272) { + parse_identity_check_status: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::bgs::protocol::account::v1::IdentityVerificationStatus_IsValid(value)) { + set_identity_check_status(static_cast< ::bgs::protocol::account::v1::IdentityVerificationStatus >(value)); + } else { + mutable_unknown_fields()->AddVarint(34, 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:bgs.protocol.account.v1.AccountBlob) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountBlob) + return false; +#undef DO_ +} + +void AccountBlob::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountBlob) + // required fixed32 id = 2; + if (has_id()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->id(), output); + } + + // required uint32 region = 3; + if (has_region()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->region(), output); + } + + // repeated string email = 4; + for (int i = 0; i < this->email_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->email(i).data(), this->email(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "email"); + ::google::protobuf::internal::WireFormatLite::WriteString( + 4, this->email(i), output); + } + + // required uint64 flags = 5; + if (has_flags()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(5, this->flags(), output); + } + + // optional uint64 secure_release = 6; + if (has_secure_release()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(6, this->secure_release(), output); + } + + // optional uint64 whitelist_start = 7; + if (has_whitelist_start()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(7, this->whitelist_start(), output); + } + + // optional uint64 whitelist_end = 8; + if (has_whitelist_end()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(8, this->whitelist_end(), output); + } + + // required string full_name = 10; + if (has_full_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->full_name().data(), this->full_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "full_name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 10, this->full_name(), output); + } + + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20; + for (int i = 0; i < this->licenses_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 20, this->licenses(i), output); + } + + // repeated .bgs.protocol.account.v1.AccountCredential credentials = 21; + for (int i = 0; i < this->credentials_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 21, this->credentials(i), output); + } + + // repeated .bgs.protocol.account.v1.GameAccountLink account_links = 22; + for (int i = 0; i < this->account_links_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 22, this->account_links(i), output); + } + + // optional string battle_tag = 23; + if (has_battle_tag()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->battle_tag().data(), this->battle_tag().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "battle_tag"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 23, this->battle_tag(), output); + } + + // optional fixed32 default_currency = 25; + if (has_default_currency()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(25, this->default_currency(), output); + } + + // optional uint32 legal_region = 26; + if (has_legal_region()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(26, this->legal_region(), output); + } + + // optional fixed32 legal_locale = 27; + if (has_legal_locale()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(27, this->legal_locale(), output); + } + + // required uint64 cache_expiration = 30; + if (has_cache_expiration()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(30, this->cache_expiration(), output); + } + + // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 31; + if (has_parental_control_info()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 31, this->parental_control_info(), output); + } + + // optional string country = 32; + if (has_country()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->country().data(), this->country().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "country"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 32, this->country(), output); + } + + // optional uint32 preferred_region = 33; + if (has_preferred_region()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(33, this->preferred_region(), output); + } + + // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 34; + if (has_identity_check_status()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 34, this->identity_check_status(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountBlob) +} + +::google::protobuf::uint8* AccountBlob::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountBlob) + // required fixed32 id = 2; + if (has_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->id(), target); + } + + // required uint32 region = 3; + if (has_region()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->region(), target); + } + + // repeated string email = 4; + for (int i = 0; i < this->email_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->email(i).data(), this->email(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "email"); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(4, this->email(i), target); + } + + // required uint64 flags = 5; + if (has_flags()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(5, this->flags(), target); + } + + // optional uint64 secure_release = 6; + if (has_secure_release()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(6, this->secure_release(), target); + } + + // optional uint64 whitelist_start = 7; + if (has_whitelist_start()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(7, this->whitelist_start(), target); + } + + // optional uint64 whitelist_end = 8; + if (has_whitelist_end()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(8, this->whitelist_end(), target); + } + + // required string full_name = 10; + if (has_full_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->full_name().data(), this->full_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "full_name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 10, this->full_name(), target); + } + + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20; + for (int i = 0; i < this->licenses_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 20, this->licenses(i), target); + } + + // repeated .bgs.protocol.account.v1.AccountCredential credentials = 21; + for (int i = 0; i < this->credentials_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 21, this->credentials(i), target); + } + + // repeated .bgs.protocol.account.v1.GameAccountLink account_links = 22; + for (int i = 0; i < this->account_links_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 22, this->account_links(i), target); + } + + // optional string battle_tag = 23; + if (has_battle_tag()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->battle_tag().data(), this->battle_tag().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "battle_tag"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 23, this->battle_tag(), target); + } + + // optional fixed32 default_currency = 25; + if (has_default_currency()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(25, this->default_currency(), target); + } + + // optional uint32 legal_region = 26; + if (has_legal_region()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(26, this->legal_region(), target); + } + + // optional fixed32 legal_locale = 27; + if (has_legal_locale()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(27, this->legal_locale(), target); + } + + // required uint64 cache_expiration = 30; + if (has_cache_expiration()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(30, this->cache_expiration(), target); + } + + // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 31; + if (has_parental_control_info()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 31, this->parental_control_info(), target); + } + + // optional string country = 32; + if (has_country()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->country().data(), this->country().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "country"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 32, this->country(), target); + } + + // optional uint32 preferred_region = 33; + if (has_preferred_region()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(33, this->preferred_region(), target); + } + + // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 34; + if (has_identity_check_status()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 34, this->identity_check_status(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountBlob) + return target; +} + +int AccountBlob::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed32 id = 2; + if (has_id()) { + total_size += 1 + 4; + } + + // required uint32 region = 3; + if (has_region()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->region()); + } + + // required uint64 flags = 5; + if (has_flags()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->flags()); + } + + // optional uint64 secure_release = 6; + if (has_secure_release()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->secure_release()); + } + + // optional uint64 whitelist_start = 7; + if (has_whitelist_start()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->whitelist_start()); + } + + // optional uint64 whitelist_end = 8; + if (has_whitelist_end()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->whitelist_end()); + } + + // required string full_name = 10; + if (has_full_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->full_name()); + } + + } + if (_has_bits_[11 / 32] & (0xffu << (11 % 32))) { + // optional string battle_tag = 23; + if (has_battle_tag()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->battle_tag()); + } + + // optional fixed32 default_currency = 25; + if (has_default_currency()) { + total_size += 2 + 4; + } + + // optional uint32 legal_region = 26; + if (has_legal_region()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->legal_region()); + } + + // optional fixed32 legal_locale = 27; + if (has_legal_locale()) { + total_size += 2 + 4; + } + + // required uint64 cache_expiration = 30; + if (has_cache_expiration()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->cache_expiration()); + } + + } + if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) { + // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 31; + if (has_parental_control_info()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->parental_control_info()); + } + + // optional string country = 32; + if (has_country()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->country()); + } + + // optional uint32 preferred_region = 33; + if (has_preferred_region()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->preferred_region()); + } + + // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 34; + if (has_identity_check_status()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->identity_check_status()); + } + + } + // repeated string email = 4; + total_size += 1 * this->email_size(); + for (int i = 0; i < this->email_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->email(i)); + } + + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20; + total_size += 2 * this->licenses_size(); + for (int i = 0; i < this->licenses_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->licenses(i)); + } + + // repeated .bgs.protocol.account.v1.AccountCredential credentials = 21; + total_size += 2 * this->credentials_size(); + for (int i = 0; i < this->credentials_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->credentials(i)); + } + + // repeated .bgs.protocol.account.v1.GameAccountLink account_links = 22; + total_size += 2 * this->account_links_size(); + for (int i = 0; i < this->account_links_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account_links(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 AccountBlob::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AccountBlob* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AccountBlob::MergeFrom(const AccountBlob& from) { + GOOGLE_CHECK_NE(&from, this); + email_.MergeFrom(from.email_); + licenses_.MergeFrom(from.licenses_); + credentials_.MergeFrom(from.credentials_); + account_links_.MergeFrom(from.account_links_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_id()) { + set_id(from.id()); + } + if (from.has_region()) { + set_region(from.region()); + } + if (from.has_flags()) { + set_flags(from.flags()); + } + if (from.has_secure_release()) { + set_secure_release(from.secure_release()); + } + if (from.has_whitelist_start()) { + set_whitelist_start(from.whitelist_start()); + } + if (from.has_whitelist_end()) { + set_whitelist_end(from.whitelist_end()); + } + if (from.has_full_name()) { + set_full_name(from.full_name()); + } + } + if (from._has_bits_[11 / 32] & (0xffu << (11 % 32))) { + if (from.has_battle_tag()) { + set_battle_tag(from.battle_tag()); + } + if (from.has_default_currency()) { + set_default_currency(from.default_currency()); + } + if (from.has_legal_region()) { + set_legal_region(from.legal_region()); + } + if (from.has_legal_locale()) { + set_legal_locale(from.legal_locale()); + } + if (from.has_cache_expiration()) { + set_cache_expiration(from.cache_expiration()); + } + } + if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) { + if (from.has_parental_control_info()) { + mutable_parental_control_info()->::bgs::protocol::account::v1::ParentalControlInfo::MergeFrom(from.parental_control_info()); + } + if (from.has_country()) { + set_country(from.country()); + } + if (from.has_preferred_region()) { + set_preferred_region(from.preferred_region()); + } + if (from.has_identity_check_status()) { + set_identity_check_status(from.identity_check_status()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AccountBlob::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AccountBlob::CopyFrom(const AccountBlob& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AccountBlob::IsInitialized() const { + if ((_has_bits_[0] & 0x0000808b) != 0x0000808b) return false; + + if (!::google::protobuf::internal::AllAreInitialized(this->licenses())) return false; + if (!::google::protobuf::internal::AllAreInitialized(this->credentials())) return false; + if (!::google::protobuf::internal::AllAreInitialized(this->account_links())) return false; + return true; +} + +void AccountBlob::Swap(AccountBlob* other) { + if (other != this) { + std::swap(id_, other->id_); + std::swap(region_, other->region_); + email_.Swap(&other->email_); + std::swap(flags_, other->flags_); + std::swap(secure_release_, other->secure_release_); + std::swap(whitelist_start_, other->whitelist_start_); + std::swap(whitelist_end_, other->whitelist_end_); + std::swap(full_name_, other->full_name_); + licenses_.Swap(&other->licenses_); + credentials_.Swap(&other->credentials_); + account_links_.Swap(&other->account_links_); + std::swap(battle_tag_, other->battle_tag_); + std::swap(default_currency_, other->default_currency_); + std::swap(legal_region_, other->legal_region_); + std::swap(legal_locale_, other->legal_locale_); + std::swap(cache_expiration_, other->cache_expiration_); + std::swap(parental_control_info_, other->parental_control_info_); + std::swap(country_, other->country_); + std::swap(preferred_region_, other->preferred_region_); + std::swap(identity_check_status_, other->identity_check_status_); + 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 AccountBlob::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AccountBlob_descriptor_; + metadata.reflection = AccountBlob_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AccountBlobList::kBlobFieldNumber; +#endif // !_MSC_VER + +AccountBlobList::AccountBlobList() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountBlobList) +} + +void AccountBlobList::InitAsDefaultInstance() { +} + +AccountBlobList::AccountBlobList(const AccountBlobList& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountBlobList) +} + +void AccountBlobList::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AccountBlobList::~AccountBlobList() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountBlobList) + SharedDtor(); +} + +void AccountBlobList::SharedDtor() { + if (this != default_instance_) { + } +} + +void AccountBlobList::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AccountBlobList::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AccountBlobList_descriptor_; +} + +const AccountBlobList& AccountBlobList::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +AccountBlobList* AccountBlobList::default_instance_ = NULL; + +AccountBlobList* AccountBlobList::New() const { + return new AccountBlobList; +} + +void AccountBlobList::Clear() { + blob_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AccountBlobList::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountBlobList) + 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 .bgs.protocol.account.v1.AccountBlob blob = 1; + case 1: { + if (tag == 10) { + parse_blob: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_blob())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_blob; + 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:bgs.protocol.account.v1.AccountBlobList) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountBlobList) + return false; +#undef DO_ +} + +void AccountBlobList::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountBlobList) + // repeated .bgs.protocol.account.v1.AccountBlob blob = 1; + for (int i = 0; i < this->blob_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->blob(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountBlobList) +} + +::google::protobuf::uint8* AccountBlobList::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountBlobList) + // repeated .bgs.protocol.account.v1.AccountBlob blob = 1; + for (int i = 0; i < this->blob_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->blob(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountBlobList) + return target; +} + +int AccountBlobList::ByteSize() const { + int total_size = 0; + + // repeated .bgs.protocol.account.v1.AccountBlob blob = 1; + total_size += 1 * this->blob_size(); + for (int i = 0; i < this->blob_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->blob(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 AccountBlobList::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AccountBlobList* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AccountBlobList::MergeFrom(const AccountBlobList& from) { + GOOGLE_CHECK_NE(&from, this); + blob_.MergeFrom(from.blob_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AccountBlobList::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AccountBlobList::CopyFrom(const AccountBlobList& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AccountBlobList::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->blob())) return false; + return true; +} + +void AccountBlobList::Swap(AccountBlobList* other) { + if (other != this) { + blob_.Swap(&other->blob_); + 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 AccountBlobList::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AccountBlobList_descriptor_; + metadata.reflection = AccountBlobList_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GameAccountHandle::kIdFieldNumber; +const int GameAccountHandle::kProgramFieldNumber; +const int GameAccountHandle::kRegionFieldNumber; +#endif // !_MSC_VER + +GameAccountHandle::GameAccountHandle() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountHandle) +} + +void GameAccountHandle::InitAsDefaultInstance() { +} + +GameAccountHandle::GameAccountHandle(const GameAccountHandle& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountHandle) +} + +void GameAccountHandle::SharedCtor() { + _cached_size_ = 0; + id_ = 0u; + program_ = 0u; + region_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameAccountHandle::~GameAccountHandle() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountHandle) + SharedDtor(); +} + +void GameAccountHandle::SharedDtor() { + if (this != default_instance_) { + } +} + +void GameAccountHandle::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GameAccountHandle::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GameAccountHandle_descriptor_; +} + +const GameAccountHandle& GameAccountHandle::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +GameAccountHandle* GameAccountHandle::default_instance_ = NULL; + +GameAccountHandle* GameAccountHandle::New() const { + return new GameAccountHandle; +} + +void GameAccountHandle::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(id_, region_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GameAccountHandle::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountHandle) + 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)) { + // required fixed32 id = 1; + case 1: { + if (tag == 13) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &id_))); + set_has_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(21)) goto parse_program; + break; + } + + // required fixed32 program = 2; + case 2: { + if (tag == 21) { + parse_program: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &program_))); + set_has_program(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_region; + break; + } + + // required uint32 region = 3; + case 3: { + if (tag == 24) { + parse_region: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, ®ion_))); + set_has_region(); + } 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:bgs.protocol.account.v1.GameAccountHandle) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountHandle) + return false; +#undef DO_ +} + +void GameAccountHandle::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountHandle) + // required fixed32 id = 1; + if (has_id()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->id(), output); + } + + // required fixed32 program = 2; + if (has_program()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->program(), output); + } + + // required uint32 region = 3; + if (has_region()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->region(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountHandle) +} + +::google::protobuf::uint8* GameAccountHandle::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountHandle) + // required fixed32 id = 1; + if (has_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->id(), target); + } + + // required fixed32 program = 2; + if (has_program()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->program(), target); + } + + // required uint32 region = 3; + if (has_region()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->region(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountHandle) + return target; +} + +int GameAccountHandle::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed32 id = 1; + if (has_id()) { + total_size += 1 + 4; + } + + // required fixed32 program = 2; + if (has_program()) { + total_size += 1 + 4; + } + + // required uint32 region = 3; + if (has_region()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->region()); + } + + } + 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 GameAccountHandle::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GameAccountHandle* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GameAccountHandle::MergeFrom(const GameAccountHandle& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_id()) { + set_id(from.id()); + } + if (from.has_program()) { + set_program(from.program()); + } + if (from.has_region()) { + set_region(from.region()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GameAccountHandle::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GameAccountHandle::CopyFrom(const GameAccountHandle& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameAccountHandle::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + return true; +} + +void GameAccountHandle::Swap(GameAccountHandle* other) { + if (other != this) { + std::swap(id_, other->id_); + std::swap(program_, other->program_); + std::swap(region_, other->region_); + 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 GameAccountHandle::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GameAccountHandle_descriptor_; + metadata.reflection = GameAccountHandle_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GameAccountLink::kGameAccountFieldNumber; +const int GameAccountLink::kNameFieldNumber; +#endif // !_MSC_VER + +GameAccountLink::GameAccountLink() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountLink) +} + +void GameAccountLink::InitAsDefaultInstance() { + game_account_ = const_cast< ::bgs::protocol::account::v1::GameAccountHandle*>(&::bgs::protocol::account::v1::GameAccountHandle::default_instance()); +} + +GameAccountLink::GameAccountLink(const GameAccountLink& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountLink) +} + +void GameAccountLink::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + game_account_ = NULL; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameAccountLink::~GameAccountLink() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountLink) + SharedDtor(); +} + +void GameAccountLink::SharedDtor() { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete name_; + } + if (this != default_instance_) { + delete game_account_; + } +} + +void GameAccountLink::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GameAccountLink::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GameAccountLink_descriptor_; +} + +const GameAccountLink& GameAccountLink::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +GameAccountLink* GameAccountLink::default_instance_ = NULL; + +GameAccountLink* GameAccountLink::New() const { + return new GameAccountLink; +} + +void GameAccountLink::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_game_account()) { + if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear(); + } + if (has_name()) { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GameAccountLink::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountLink) + 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)) { + // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_name; + break; + } + + // required 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:bgs.protocol.account.v1.GameAccountLink) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountLink) + return false; +#undef DO_ +} + +void GameAccountLink::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountLink) + // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1; + if (has_game_account()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->game_account(), output); + } + + // required 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:bgs.protocol.account.v1.GameAccountLink) +} + +::google::protobuf::uint8* GameAccountLink::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountLink) + // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1; + if (has_game_account()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->game_account(), target); + } + + // required 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:bgs.protocol.account.v1.GameAccountLink) + return target; +} + +int GameAccountLink::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1; + if (has_game_account()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account()); + } + + // required 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 GameAccountLink::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GameAccountLink* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GameAccountLink::MergeFrom(const GameAccountLink& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_game_account()) { + mutable_game_account()->::bgs::protocol::account::v1::GameAccountHandle::MergeFrom(from.game_account()); + } + if (from.has_name()) { + set_name(from.name()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GameAccountLink::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GameAccountLink::CopyFrom(const GameAccountLink& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameAccountLink::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + if (has_game_account()) { + if (!this->game_account().IsInitialized()) return false; + } + return true; +} + +void GameAccountLink::Swap(GameAccountLink* other) { + if (other != this) { + std::swap(game_account_, other->game_account_); + 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 GameAccountLink::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GameAccountLink_descriptor_; + metadata.reflection = GameAccountLink_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GameAccountBlob::kGameAccountFieldNumber; +const int GameAccountBlob::kNameFieldNumber; +const int GameAccountBlob::kRealmPermissionsFieldNumber; +const int GameAccountBlob::kStatusFieldNumber; +const int GameAccountBlob::kFlagsFieldNumber; +const int GameAccountBlob::kBillingFlagsFieldNumber; +const int GameAccountBlob::kCacheExpirationFieldNumber; +const int GameAccountBlob::kSubscriptionExpirationFieldNumber; +const int GameAccountBlob::kUnitsRemainingFieldNumber; +const int GameAccountBlob::kStatusExpirationFieldNumber; +const int GameAccountBlob::kBoxLevelFieldNumber; +const int GameAccountBlob::kBoxLevelExpirationFieldNumber; +const int GameAccountBlob::kLicensesFieldNumber; +const int GameAccountBlob::kRafAccountFieldNumber; +const int GameAccountBlob::kRafInfoFieldNumber; +const int GameAccountBlob::kRafExpirationFieldNumber; +#endif // !_MSC_VER + +GameAccountBlob::GameAccountBlob() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountBlob) +} + +void GameAccountBlob::InitAsDefaultInstance() { + game_account_ = const_cast< ::bgs::protocol::account::v1::GameAccountHandle*>(&::bgs::protocol::account::v1::GameAccountHandle::default_instance()); +} + +GameAccountBlob::GameAccountBlob(const GameAccountBlob& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountBlob) +} + +void GameAccountBlob::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + game_account_ = NULL; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + realm_permissions_ = 0u; + status_ = 0u; + flags_ = GOOGLE_ULONGLONG(0); + billing_flags_ = 0u; + cache_expiration_ = GOOGLE_ULONGLONG(0); + subscription_expiration_ = GOOGLE_ULONGLONG(0); + units_remaining_ = 0u; + status_expiration_ = GOOGLE_ULONGLONG(0); + box_level_ = 0u; + box_level_expiration_ = GOOGLE_ULONGLONG(0); + raf_account_ = 0u; + raf_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + raf_expiration_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameAccountBlob::~GameAccountBlob() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountBlob) + SharedDtor(); +} + +void GameAccountBlob::SharedDtor() { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete name_; + } + if (raf_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete raf_info_; + } + if (this != default_instance_) { + delete game_account_; + } +} + +void GameAccountBlob::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GameAccountBlob::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GameAccountBlob_descriptor_; +} + +const GameAccountBlob& GameAccountBlob::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +GameAccountBlob* GameAccountBlob::default_instance_ = NULL; + +GameAccountBlob* GameAccountBlob::New() const { + return new GameAccountBlob; +} + +void GameAccountBlob::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(realm_permissions_, billing_flags_); + if (has_game_account()) { + if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear(); + } + if (has_name()) { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_->clear(); + } + } + subscription_expiration_ = GOOGLE_ULONGLONG(0); + } + if (_has_bits_[8 / 32] & 61184) { + ZR_(status_expiration_, raf_account_); + units_remaining_ = 0u; + if (has_raf_info()) { + if (raf_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + raf_info_->clear(); + } + } + raf_expiration_ = GOOGLE_ULONGLONG(0); + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + licenses_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GameAccountBlob::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountBlob) + 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)) { + // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_name; + break; + } + + // optional string name = 2 [default = ""]; + 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(24)) goto parse_realm_permissions; + break; + } + + // optional uint32 realm_permissions = 3 [default = 0]; + case 3: { + if (tag == 24) { + parse_realm_permissions: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &realm_permissions_))); + set_has_realm_permissions(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_status; + break; + } + + // required uint32 status = 4; + case 4: { + if (tag == 32) { + parse_status: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &status_))); + set_has_status(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_flags; + break; + } + + // optional uint64 flags = 5 [default = 0]; + case 5: { + if (tag == 40) { + parse_flags: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &flags_))); + set_has_flags(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_billing_flags; + break; + } + + // optional uint32 billing_flags = 6 [default = 0]; + case 6: { + if (tag == 48) { + parse_billing_flags: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &billing_flags_))); + set_has_billing_flags(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(56)) goto parse_cache_expiration; + break; + } + + // required uint64 cache_expiration = 7; + case 7: { + if (tag == 56) { + parse_cache_expiration: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &cache_expiration_))); + set_has_cache_expiration(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(80)) goto parse_subscription_expiration; + break; + } + + // optional uint64 subscription_expiration = 10; + case 10: { + if (tag == 80) { + parse_subscription_expiration: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &subscription_expiration_))); + set_has_subscription_expiration(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(88)) goto parse_units_remaining; + break; + } + + // optional uint32 units_remaining = 11; + case 11: { + if (tag == 88) { + parse_units_remaining: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &units_remaining_))); + set_has_units_remaining(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(96)) goto parse_status_expiration; + break; + } + + // optional uint64 status_expiration = 12; + case 12: { + if (tag == 96) { + parse_status_expiration: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &status_expiration_))); + set_has_status_expiration(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(104)) goto parse_box_level; + break; + } + + // optional uint32 box_level = 13; + case 13: { + if (tag == 104) { + parse_box_level: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &box_level_))); + set_has_box_level(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(112)) goto parse_box_level_expiration; + break; + } + + // optional uint64 box_level_expiration = 14; + case 14: { + if (tag == 112) { + parse_box_level_expiration: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &box_level_expiration_))); + set_has_box_level_expiration(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(162)) goto parse_licenses; + break; + } + + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20; + case 20: { + if (tag == 162) { + parse_licenses: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_licenses())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(162)) goto parse_licenses; + if (input->ExpectTag(173)) goto parse_raf_account; + break; + } + + // optional fixed32 raf_account = 21; + case 21: { + if (tag == 173) { + parse_raf_account: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &raf_account_))); + set_has_raf_account(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(178)) goto parse_raf_info; + break; + } + + // optional bytes raf_info = 22; + case 22: { + if (tag == 178) { + parse_raf_info: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_raf_info())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(184)) goto parse_raf_expiration; + break; + } + + // optional uint64 raf_expiration = 23; + case 23: { + if (tag == 184) { + parse_raf_expiration: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &raf_expiration_))); + set_has_raf_expiration(); + } 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:bgs.protocol.account.v1.GameAccountBlob) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountBlob) + return false; +#undef DO_ +} + +void GameAccountBlob::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountBlob) + // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1; + if (has_game_account()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->game_account(), output); + } + + // optional string name = 2 [default = ""]; + 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); + } + + // optional uint32 realm_permissions = 3 [default = 0]; + if (has_realm_permissions()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->realm_permissions(), output); + } + + // required uint32 status = 4; + if (has_status()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->status(), output); + } + + // optional uint64 flags = 5 [default = 0]; + if (has_flags()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(5, this->flags(), output); + } + + // optional uint32 billing_flags = 6 [default = 0]; + if (has_billing_flags()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->billing_flags(), output); + } + + // required uint64 cache_expiration = 7; + if (has_cache_expiration()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(7, this->cache_expiration(), output); + } + + // optional uint64 subscription_expiration = 10; + if (has_subscription_expiration()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(10, this->subscription_expiration(), output); + } + + // optional uint32 units_remaining = 11; + if (has_units_remaining()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(11, this->units_remaining(), output); + } + + // optional uint64 status_expiration = 12; + if (has_status_expiration()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(12, this->status_expiration(), output); + } + + // optional uint32 box_level = 13; + if (has_box_level()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(13, this->box_level(), output); + } + + // optional uint64 box_level_expiration = 14; + if (has_box_level_expiration()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(14, this->box_level_expiration(), output); + } + + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20; + for (int i = 0; i < this->licenses_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 20, this->licenses(i), output); + } + + // optional fixed32 raf_account = 21; + if (has_raf_account()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(21, this->raf_account(), output); + } + + // optional bytes raf_info = 22; + if (has_raf_info()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 22, this->raf_info(), output); + } + + // optional uint64 raf_expiration = 23; + if (has_raf_expiration()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(23, this->raf_expiration(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountBlob) +} + +::google::protobuf::uint8* GameAccountBlob::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountBlob) + // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1; + if (has_game_account()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->game_account(), target); + } + + // optional string name = 2 [default = ""]; + 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); + } + + // optional uint32 realm_permissions = 3 [default = 0]; + if (has_realm_permissions()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->realm_permissions(), target); + } + + // required uint32 status = 4; + if (has_status()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->status(), target); + } + + // optional uint64 flags = 5 [default = 0]; + if (has_flags()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(5, this->flags(), target); + } + + // optional uint32 billing_flags = 6 [default = 0]; + if (has_billing_flags()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->billing_flags(), target); + } + + // required uint64 cache_expiration = 7; + if (has_cache_expiration()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(7, this->cache_expiration(), target); + } + + // optional uint64 subscription_expiration = 10; + if (has_subscription_expiration()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(10, this->subscription_expiration(), target); + } + + // optional uint32 units_remaining = 11; + if (has_units_remaining()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(11, this->units_remaining(), target); + } + + // optional uint64 status_expiration = 12; + if (has_status_expiration()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(12, this->status_expiration(), target); + } + + // optional uint32 box_level = 13; + if (has_box_level()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(13, this->box_level(), target); + } + + // optional uint64 box_level_expiration = 14; + if (has_box_level_expiration()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(14, this->box_level_expiration(), target); + } + + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20; + for (int i = 0; i < this->licenses_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 20, this->licenses(i), target); + } + + // optional fixed32 raf_account = 21; + if (has_raf_account()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(21, this->raf_account(), target); + } + + // optional bytes raf_info = 22; + if (has_raf_info()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 22, this->raf_info(), target); + } + + // optional uint64 raf_expiration = 23; + if (has_raf_expiration()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(23, this->raf_expiration(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountBlob) + return target; +} + +int GameAccountBlob::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1; + if (has_game_account()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account()); + } + + // optional string name = 2 [default = ""]; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // optional uint32 realm_permissions = 3 [default = 0]; + if (has_realm_permissions()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->realm_permissions()); + } + + // required uint32 status = 4; + if (has_status()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->status()); + } + + // optional uint64 flags = 5 [default = 0]; + if (has_flags()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->flags()); + } + + // optional uint32 billing_flags = 6 [default = 0]; + if (has_billing_flags()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->billing_flags()); + } + + // required uint64 cache_expiration = 7; + if (has_cache_expiration()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->cache_expiration()); + } + + // optional uint64 subscription_expiration = 10; + if (has_subscription_expiration()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->subscription_expiration()); + } + + } + if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + // optional uint32 units_remaining = 11; + if (has_units_remaining()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->units_remaining()); + } + + // optional uint64 status_expiration = 12; + if (has_status_expiration()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->status_expiration()); + } + + // optional uint32 box_level = 13; + if (has_box_level()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->box_level()); + } + + // optional uint64 box_level_expiration = 14; + if (has_box_level_expiration()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->box_level_expiration()); + } + + // optional fixed32 raf_account = 21; + if (has_raf_account()) { + total_size += 2 + 4; + } + + // optional bytes raf_info = 22; + if (has_raf_info()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->raf_info()); + } + + // optional uint64 raf_expiration = 23; + if (has_raf_expiration()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->raf_expiration()); + } + + } + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20; + total_size += 2 * this->licenses_size(); + for (int i = 0; i < this->licenses_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->licenses(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 GameAccountBlob::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GameAccountBlob* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GameAccountBlob::MergeFrom(const GameAccountBlob& from) { + GOOGLE_CHECK_NE(&from, this); + licenses_.MergeFrom(from.licenses_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_game_account()) { + mutable_game_account()->::bgs::protocol::account::v1::GameAccountHandle::MergeFrom(from.game_account()); + } + if (from.has_name()) { + set_name(from.name()); + } + if (from.has_realm_permissions()) { + set_realm_permissions(from.realm_permissions()); + } + if (from.has_status()) { + set_status(from.status()); + } + if (from.has_flags()) { + set_flags(from.flags()); + } + if (from.has_billing_flags()) { + set_billing_flags(from.billing_flags()); + } + if (from.has_cache_expiration()) { + set_cache_expiration(from.cache_expiration()); + } + if (from.has_subscription_expiration()) { + set_subscription_expiration(from.subscription_expiration()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from.has_units_remaining()) { + set_units_remaining(from.units_remaining()); + } + if (from.has_status_expiration()) { + set_status_expiration(from.status_expiration()); + } + if (from.has_box_level()) { + set_box_level(from.box_level()); + } + if (from.has_box_level_expiration()) { + set_box_level_expiration(from.box_level_expiration()); + } + if (from.has_raf_account()) { + set_raf_account(from.raf_account()); + } + if (from.has_raf_info()) { + set_raf_info(from.raf_info()); + } + if (from.has_raf_expiration()) { + set_raf_expiration(from.raf_expiration()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GameAccountBlob::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GameAccountBlob::CopyFrom(const GameAccountBlob& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameAccountBlob::IsInitialized() const { + if ((_has_bits_[0] & 0x00000049) != 0x00000049) return false; + + if (has_game_account()) { + if (!this->game_account().IsInitialized()) return false; + } + if (!::google::protobuf::internal::AllAreInitialized(this->licenses())) return false; + return true; +} + +void GameAccountBlob::Swap(GameAccountBlob* other) { + if (other != this) { + std::swap(game_account_, other->game_account_); + std::swap(name_, other->name_); + std::swap(realm_permissions_, other->realm_permissions_); + std::swap(status_, other->status_); + std::swap(flags_, other->flags_); + std::swap(billing_flags_, other->billing_flags_); + std::swap(cache_expiration_, other->cache_expiration_); + std::swap(subscription_expiration_, other->subscription_expiration_); + std::swap(units_remaining_, other->units_remaining_); + std::swap(status_expiration_, other->status_expiration_); + std::swap(box_level_, other->box_level_); + std::swap(box_level_expiration_, other->box_level_expiration_); + licenses_.Swap(&other->licenses_); + std::swap(raf_account_, other->raf_account_); + std::swap(raf_info_, other->raf_info_); + std::swap(raf_expiration_, other->raf_expiration_); + 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 GameAccountBlob::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GameAccountBlob_descriptor_; + metadata.reflection = GameAccountBlob_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GameAccountBlobList::kBlobFieldNumber; +#endif // !_MSC_VER + +GameAccountBlobList::GameAccountBlobList() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountBlobList) +} + +void GameAccountBlobList::InitAsDefaultInstance() { +} + +GameAccountBlobList::GameAccountBlobList(const GameAccountBlobList& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountBlobList) +} + +void GameAccountBlobList::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameAccountBlobList::~GameAccountBlobList() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountBlobList) + SharedDtor(); +} + +void GameAccountBlobList::SharedDtor() { + if (this != default_instance_) { + } +} + +void GameAccountBlobList::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GameAccountBlobList::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GameAccountBlobList_descriptor_; +} + +const GameAccountBlobList& GameAccountBlobList::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +GameAccountBlobList* GameAccountBlobList::default_instance_ = NULL; + +GameAccountBlobList* GameAccountBlobList::New() const { + return new GameAccountBlobList; +} + +void GameAccountBlobList::Clear() { + blob_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GameAccountBlobList::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountBlobList) + 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 .bgs.protocol.account.v1.GameAccountBlob blob = 1; + case 1: { + if (tag == 10) { + parse_blob: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_blob())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_blob; + 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:bgs.protocol.account.v1.GameAccountBlobList) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountBlobList) + return false; +#undef DO_ +} + +void GameAccountBlobList::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountBlobList) + // repeated .bgs.protocol.account.v1.GameAccountBlob blob = 1; + for (int i = 0; i < this->blob_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->blob(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountBlobList) +} + +::google::protobuf::uint8* GameAccountBlobList::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountBlobList) + // repeated .bgs.protocol.account.v1.GameAccountBlob blob = 1; + for (int i = 0; i < this->blob_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->blob(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountBlobList) + return target; +} + +int GameAccountBlobList::ByteSize() const { + int total_size = 0; + + // repeated .bgs.protocol.account.v1.GameAccountBlob blob = 1; + total_size += 1 * this->blob_size(); + for (int i = 0; i < this->blob_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->blob(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 GameAccountBlobList::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GameAccountBlobList* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GameAccountBlobList::MergeFrom(const GameAccountBlobList& from) { + GOOGLE_CHECK_NE(&from, this); + blob_.MergeFrom(from.blob_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GameAccountBlobList::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GameAccountBlobList::CopyFrom(const GameAccountBlobList& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameAccountBlobList::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->blob())) return false; + return true; +} + +void GameAccountBlobList::Swap(GameAccountBlobList* other) { + if (other != this) { + blob_.Swap(&other->blob_); + 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 GameAccountBlobList::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GameAccountBlobList_descriptor_; + metadata.reflection = GameAccountBlobList_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AccountReference::kIdFieldNumber; +const int AccountReference::kEmailFieldNumber; +const int AccountReference::kHandleFieldNumber; +const int AccountReference::kBattleTagFieldNumber; +const int AccountReference::kRegionFieldNumber; +#endif // !_MSC_VER + +AccountReference::AccountReference() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountReference) +} + +void AccountReference::InitAsDefaultInstance() { + handle_ = const_cast< ::bgs::protocol::account::v1::GameAccountHandle*>(&::bgs::protocol::account::v1::GameAccountHandle::default_instance()); +} + +AccountReference::AccountReference(const AccountReference& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountReference) +} + +void AccountReference::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + id_ = 0u; + email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + handle_ = NULL; + battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + region_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AccountReference::~AccountReference() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountReference) + SharedDtor(); +} + +void AccountReference::SharedDtor() { + if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete email_; + } + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete battle_tag_; + } + if (this != default_instance_) { + delete handle_; + } +} + +void AccountReference::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AccountReference::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AccountReference_descriptor_; +} + +const AccountReference& AccountReference::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +AccountReference* AccountReference::default_instance_ = NULL; + +AccountReference* AccountReference::New() const { + return new AccountReference; +} + +void AccountReference::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(id_, region_); + if (has_email()) { + if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_->clear(); + } + } + if (has_handle()) { + if (handle_ != NULL) handle_->::bgs::protocol::account::v1::GameAccountHandle::Clear(); + } + if (has_battle_tag()) { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_->clear(); + } + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AccountReference::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountReference) + 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 id = 1; + case 1: { + if (tag == 13) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &id_))); + set_has_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_email; + break; + } + + // optional string email = 2; + case 2: { + if (tag == 18) { + parse_email: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_email())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->email().data(), this->email().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "email"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_handle; + break; + } + + // optional .bgs.protocol.account.v1.GameAccountHandle handle = 3; + case 3: { + if (tag == 26) { + parse_handle: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_handle())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_battle_tag; + break; + } + + // optional string battle_tag = 4; + case 4: { + if (tag == 34) { + parse_battle_tag: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_battle_tag())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->battle_tag().data(), this->battle_tag().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "battle_tag"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(80)) goto parse_region; + break; + } + + // optional uint32 region = 10 [default = 0]; + case 10: { + if (tag == 80) { + parse_region: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, ®ion_))); + set_has_region(); + } 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:bgs.protocol.account.v1.AccountReference) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountReference) + return false; +#undef DO_ +} + +void AccountReference::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountReference) + // optional fixed32 id = 1; + if (has_id()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->id(), output); + } + + // optional string email = 2; + if (has_email()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->email().data(), this->email().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "email"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->email(), output); + } + + // optional .bgs.protocol.account.v1.GameAccountHandle handle = 3; + if (has_handle()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->handle(), output); + } + + // optional string battle_tag = 4; + if (has_battle_tag()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->battle_tag().data(), this->battle_tag().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "battle_tag"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 4, this->battle_tag(), output); + } + + // optional uint32 region = 10 [default = 0]; + if (has_region()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(10, this->region(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountReference) +} + +::google::protobuf::uint8* AccountReference::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountReference) + // optional fixed32 id = 1; + if (has_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->id(), target); + } + + // optional string email = 2; + if (has_email()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->email().data(), this->email().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "email"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->email(), target); + } + + // optional .bgs.protocol.account.v1.GameAccountHandle handle = 3; + if (has_handle()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->handle(), target); + } + + // optional string battle_tag = 4; + if (has_battle_tag()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->battle_tag().data(), this->battle_tag().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "battle_tag"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->battle_tag(), target); + } + + // optional uint32 region = 10 [default = 0]; + if (has_region()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(10, this->region(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountReference) + return target; +} + +int AccountReference::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional fixed32 id = 1; + if (has_id()) { + total_size += 1 + 4; + } + + // optional string email = 2; + if (has_email()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->email()); + } + + // optional .bgs.protocol.account.v1.GameAccountHandle handle = 3; + if (has_handle()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->handle()); + } + + // optional string battle_tag = 4; + if (has_battle_tag()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->battle_tag()); + } + + // optional uint32 region = 10 [default = 0]; + if (has_region()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->region()); + } + + } + 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 AccountReference::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AccountReference* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AccountReference::MergeFrom(const AccountReference& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_id()) { + set_id(from.id()); + } + if (from.has_email()) { + set_email(from.email()); + } + if (from.has_handle()) { + mutable_handle()->::bgs::protocol::account::v1::GameAccountHandle::MergeFrom(from.handle()); + } + if (from.has_battle_tag()) { + set_battle_tag(from.battle_tag()); + } + if (from.has_region()) { + set_region(from.region()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AccountReference::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AccountReference::CopyFrom(const AccountReference& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AccountReference::IsInitialized() const { + + if (has_handle()) { + if (!this->handle().IsInitialized()) return false; + } + return true; +} + +void AccountReference::Swap(AccountReference* other) { + if (other != this) { + std::swap(id_, other->id_); + std::swap(email_, other->email_); + std::swap(handle_, other->handle_); + std::swap(battle_tag_, other->battle_tag_); + std::swap(region_, other->region_); + 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 AccountReference::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AccountReference_descriptor_; + metadata.reflection = AccountReference_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int Identity::kAccountFieldNumber; +const int Identity::kGameAccountFieldNumber; +const int Identity::kProcessFieldNumber; +#endif // !_MSC_VER + +Identity::Identity() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.Identity) +} + +void Identity::InitAsDefaultInstance() { + account_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance()); + game_account_ = const_cast< ::bgs::protocol::account::v1::GameAccountHandle*>(&::bgs::protocol::account::v1::GameAccountHandle::default_instance()); + process_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance()); +} + +Identity::Identity(const Identity& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.Identity) +} + +void Identity::SharedCtor() { + _cached_size_ = 0; + account_ = NULL; + game_account_ = NULL; + process_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Identity::~Identity() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.Identity) + SharedDtor(); +} + +void Identity::SharedDtor() { + if (this != default_instance_) { + delete account_; + delete game_account_; + delete process_; + } +} + +void Identity::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Identity::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Identity_descriptor_; +} + +const Identity& Identity::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +Identity* Identity::default_instance_ = NULL; + +Identity* Identity::New() const { + return new Identity; +} + +void Identity::Clear() { + if (_has_bits_[0 / 32] & 7) { + if (has_account()) { + if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear(); + } + if (has_game_account()) { + if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear(); + } + if (has_process()) { + if (process_ != NULL) process_->::bgs::protocol::ProcessId::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Identity::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.Identity) + 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 .bgs.protocol.account.v1.AccountId account = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_game_account; + break; + } + + // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 2; + case 2: { + if (tag == 18) { + parse_game_account: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_process; + break; + } + + // optional .bgs.protocol.ProcessId process = 3; + case 3: { + if (tag == 26) { + parse_process: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_process())); + } 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:bgs.protocol.account.v1.Identity) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.Identity) + return false; +#undef DO_ +} + +void Identity::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.Identity) + // optional .bgs.protocol.account.v1.AccountId account = 1; + if (has_account()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->account(), output); + } + + // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 2; + if (has_game_account()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->game_account(), output); + } + + // optional .bgs.protocol.ProcessId process = 3; + if (has_process()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->process(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.Identity) +} + +::google::protobuf::uint8* Identity::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.Identity) + // optional .bgs.protocol.account.v1.AccountId account = 1; + if (has_account()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->account(), target); + } + + // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 2; + if (has_game_account()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->game_account(), target); + } + + // optional .bgs.protocol.ProcessId process = 3; + if (has_process()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->process(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.Identity) + return target; +} + +int Identity::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.account.v1.AccountId account = 1; + if (has_account()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account()); + } + + // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 2; + if (has_game_account()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account()); + } + + // optional .bgs.protocol.ProcessId process = 3; + if (has_process()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->process()); + } + + } + 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 Identity::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Identity* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Identity::MergeFrom(const Identity& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_account()) { + mutable_account()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.account()); + } + if (from.has_game_account()) { + mutable_game_account()->::bgs::protocol::account::v1::GameAccountHandle::MergeFrom(from.game_account()); + } + if (from.has_process()) { + mutable_process()->::bgs::protocol::ProcessId::MergeFrom(from.process()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Identity::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Identity::CopyFrom(const Identity& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Identity::IsInitialized() const { + + if (has_account()) { + if (!this->account().IsInitialized()) return false; + } + if (has_game_account()) { + if (!this->game_account().IsInitialized()) return false; + } + if (has_process()) { + if (!this->process().IsInitialized()) return false; + } + return true; +} + +void Identity::Swap(Identity* other) { + if (other != this) { + std::swap(account_, other->account_); + std::swap(game_account_, other->game_account_); + std::swap(process_, other->process_); + 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 Identity::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Identity_descriptor_; + metadata.reflection = Identity_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ProgramTag::kProgramFieldNumber; +const int ProgramTag::kTagFieldNumber; +#endif // !_MSC_VER + +ProgramTag::ProgramTag() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.ProgramTag) +} + +void ProgramTag::InitAsDefaultInstance() { +} + +ProgramTag::ProgramTag(const ProgramTag& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.ProgramTag) +} + +void ProgramTag::SharedCtor() { + _cached_size_ = 0; + program_ = 0u; + tag_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ProgramTag::~ProgramTag() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.ProgramTag) + SharedDtor(); +} + +void ProgramTag::SharedDtor() { + if (this != default_instance_) { + } +} + +void ProgramTag::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ProgramTag::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ProgramTag_descriptor_; +} + +const ProgramTag& ProgramTag::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +ProgramTag* ProgramTag::default_instance_ = NULL; + +ProgramTag* ProgramTag::New() const { + return new ProgramTag; +} + +void ProgramTag::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(program_, tag_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ProgramTag::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.ProgramTag) + 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 program = 1; + case 1: { + if (tag == 13) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &program_))); + set_has_program(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(21)) goto parse_tag; + break; + } + + // optional fixed32 tag = 2; + case 2: { + if (tag == 21) { + parse_tag: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &tag_))); + set_has_tag(); + } 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:bgs.protocol.account.v1.ProgramTag) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.ProgramTag) + return false; +#undef DO_ +} + +void ProgramTag::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.ProgramTag) + // optional fixed32 program = 1; + if (has_program()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->program(), output); + } + + // optional fixed32 tag = 2; + if (has_tag()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->tag(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.ProgramTag) +} + +::google::protobuf::uint8* ProgramTag::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.ProgramTag) + // optional fixed32 program = 1; + if (has_program()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->program(), target); + } + + // optional fixed32 tag = 2; + if (has_tag()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->tag(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.ProgramTag) + return target; +} + +int ProgramTag::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional fixed32 program = 1; + if (has_program()) { + total_size += 1 + 4; + } + + // optional fixed32 tag = 2; + if (has_tag()) { + 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 ProgramTag::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ProgramTag* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ProgramTag::MergeFrom(const ProgramTag& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_program()) { + set_program(from.program()); + } + if (from.has_tag()) { + set_tag(from.tag()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ProgramTag::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ProgramTag::CopyFrom(const ProgramTag& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ProgramTag::IsInitialized() const { + + return true; +} + +void ProgramTag::Swap(ProgramTag* other) { + if (other != this) { + std::swap(program_, other->program_); + std::swap(tag_, other->tag_); + 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 ProgramTag::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ProgramTag_descriptor_; + metadata.reflection = ProgramTag_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int RegionTag::kRegionFieldNumber; +const int RegionTag::kTagFieldNumber; +#endif // !_MSC_VER + +RegionTag::RegionTag() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.RegionTag) +} + +void RegionTag::InitAsDefaultInstance() { +} + +RegionTag::RegionTag(const RegionTag& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.RegionTag) +} + +void RegionTag::SharedCtor() { + _cached_size_ = 0; + region_ = 0u; + tag_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +RegionTag::~RegionTag() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.RegionTag) + SharedDtor(); +} + +void RegionTag::SharedDtor() { + if (this != default_instance_) { + } +} + +void RegionTag::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* RegionTag::descriptor() { + protobuf_AssignDescriptorsOnce(); + return RegionTag_descriptor_; +} + +const RegionTag& RegionTag::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +RegionTag* RegionTag::default_instance_ = NULL; + +RegionTag* RegionTag::New() const { + return new RegionTag; +} + +void RegionTag::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(region_, tag_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool RegionTag::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.RegionTag) + 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 region = 1; + case 1: { + if (tag == 13) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, ®ion_))); + set_has_region(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(21)) goto parse_tag; + break; + } + + // optional fixed32 tag = 2; + case 2: { + if (tag == 21) { + parse_tag: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &tag_))); + set_has_tag(); + } 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:bgs.protocol.account.v1.RegionTag) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.RegionTag) + return false; +#undef DO_ +} + +void RegionTag::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.RegionTag) + // optional fixed32 region = 1; + if (has_region()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->region(), output); + } + + // optional fixed32 tag = 2; + if (has_tag()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->tag(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.RegionTag) +} + +::google::protobuf::uint8* RegionTag::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.RegionTag) + // optional fixed32 region = 1; + if (has_region()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->region(), target); + } + + // optional fixed32 tag = 2; + if (has_tag()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->tag(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.RegionTag) + return target; +} + +int RegionTag::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional fixed32 region = 1; + if (has_region()) { + total_size += 1 + 4; + } + + // optional fixed32 tag = 2; + if (has_tag()) { + 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 RegionTag::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const RegionTag* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void RegionTag::MergeFrom(const RegionTag& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_region()) { + set_region(from.region()); + } + if (from.has_tag()) { + set_tag(from.tag()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void RegionTag::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RegionTag::CopyFrom(const RegionTag& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RegionTag::IsInitialized() const { + + return true; +} + +void RegionTag::Swap(RegionTag* other) { + if (other != this) { + std::swap(region_, other->region_); + std::swap(tag_, other->tag_); + 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 RegionTag::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = RegionTag_descriptor_; + metadata.reflection = RegionTag_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AccountFieldTags::kAccountLevelInfoTagFieldNumber; +const int AccountFieldTags::kPrivacyInfoTagFieldNumber; +const int AccountFieldTags::kParentalControlInfoTagFieldNumber; +const int AccountFieldTags::kGameLevelInfoTagsFieldNumber; +const int AccountFieldTags::kGameStatusTagsFieldNumber; +const int AccountFieldTags::kGameAccountTagsFieldNumber; +#endif // !_MSC_VER + +AccountFieldTags::AccountFieldTags() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountFieldTags) +} + +void AccountFieldTags::InitAsDefaultInstance() { +} + +AccountFieldTags::AccountFieldTags(const AccountFieldTags& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountFieldTags) +} + +void AccountFieldTags::SharedCtor() { + _cached_size_ = 0; + account_level_info_tag_ = 0u; + privacy_info_tag_ = 0u; + parental_control_info_tag_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AccountFieldTags::~AccountFieldTags() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountFieldTags) + SharedDtor(); +} + +void AccountFieldTags::SharedDtor() { + if (this != default_instance_) { + } +} + +void AccountFieldTags::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AccountFieldTags::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AccountFieldTags_descriptor_; +} + +const AccountFieldTags& AccountFieldTags::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +AccountFieldTags* AccountFieldTags::default_instance_ = NULL; + +AccountFieldTags* AccountFieldTags::New() const { + return new AccountFieldTags; +} + +void AccountFieldTags::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(account_level_info_tag_, privacy_info_tag_); + parental_control_info_tag_ = 0u; + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + game_level_info_tags_.Clear(); + game_status_tags_.Clear(); + game_account_tags_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AccountFieldTags::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountFieldTags) + 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 account_level_info_tag = 2; + case 2: { + if (tag == 21) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &account_level_info_tag_))); + set_has_account_level_info_tag(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(29)) goto parse_privacy_info_tag; + break; + } + + // optional fixed32 privacy_info_tag = 3; + case 3: { + if (tag == 29) { + parse_privacy_info_tag: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &privacy_info_tag_))); + set_has_privacy_info_tag(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(37)) goto parse_parental_control_info_tag; + break; + } + + // optional fixed32 parental_control_info_tag = 4; + case 4: { + if (tag == 37) { + parse_parental_control_info_tag: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &parental_control_info_tag_))); + set_has_parental_control_info_tag(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(58)) goto parse_game_level_info_tags; + break; + } + + // repeated .bgs.protocol.account.v1.ProgramTag game_level_info_tags = 7; + case 7: { + if (tag == 58) { + parse_game_level_info_tags: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_game_level_info_tags())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(58)) goto parse_game_level_info_tags; + if (input->ExpectTag(74)) goto parse_game_status_tags; + break; + } + + // repeated .bgs.protocol.account.v1.ProgramTag game_status_tags = 9; + case 9: { + if (tag == 74) { + parse_game_status_tags: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_game_status_tags())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(74)) goto parse_game_status_tags; + if (input->ExpectTag(90)) goto parse_game_account_tags; + break; + } + + // repeated .bgs.protocol.account.v1.RegionTag game_account_tags = 11; + case 11: { + if (tag == 90) { + parse_game_account_tags: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_game_account_tags())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(90)) goto parse_game_account_tags; + 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:bgs.protocol.account.v1.AccountFieldTags) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountFieldTags) + return false; +#undef DO_ +} + +void AccountFieldTags::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountFieldTags) + // optional fixed32 account_level_info_tag = 2; + if (has_account_level_info_tag()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->account_level_info_tag(), output); + } + + // optional fixed32 privacy_info_tag = 3; + if (has_privacy_info_tag()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->privacy_info_tag(), output); + } + + // optional fixed32 parental_control_info_tag = 4; + if (has_parental_control_info_tag()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->parental_control_info_tag(), output); + } + + // repeated .bgs.protocol.account.v1.ProgramTag game_level_info_tags = 7; + for (int i = 0; i < this->game_level_info_tags_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 7, this->game_level_info_tags(i), output); + } + + // repeated .bgs.protocol.account.v1.ProgramTag game_status_tags = 9; + for (int i = 0; i < this->game_status_tags_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 9, this->game_status_tags(i), output); + } + + // repeated .bgs.protocol.account.v1.RegionTag game_account_tags = 11; + for (int i = 0; i < this->game_account_tags_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 11, this->game_account_tags(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountFieldTags) +} + +::google::protobuf::uint8* AccountFieldTags::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountFieldTags) + // optional fixed32 account_level_info_tag = 2; + if (has_account_level_info_tag()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->account_level_info_tag(), target); + } + + // optional fixed32 privacy_info_tag = 3; + if (has_privacy_info_tag()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->privacy_info_tag(), target); + } + + // optional fixed32 parental_control_info_tag = 4; + if (has_parental_control_info_tag()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->parental_control_info_tag(), target); + } + + // repeated .bgs.protocol.account.v1.ProgramTag game_level_info_tags = 7; + for (int i = 0; i < this->game_level_info_tags_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 7, this->game_level_info_tags(i), target); + } + + // repeated .bgs.protocol.account.v1.ProgramTag game_status_tags = 9; + for (int i = 0; i < this->game_status_tags_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 9, this->game_status_tags(i), target); + } + + // repeated .bgs.protocol.account.v1.RegionTag game_account_tags = 11; + for (int i = 0; i < this->game_account_tags_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 11, this->game_account_tags(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountFieldTags) + return target; +} + +int AccountFieldTags::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional fixed32 account_level_info_tag = 2; + if (has_account_level_info_tag()) { + total_size += 1 + 4; + } + + // optional fixed32 privacy_info_tag = 3; + if (has_privacy_info_tag()) { + total_size += 1 + 4; + } + + // optional fixed32 parental_control_info_tag = 4; + if (has_parental_control_info_tag()) { + total_size += 1 + 4; + } + + } + // repeated .bgs.protocol.account.v1.ProgramTag game_level_info_tags = 7; + total_size += 1 * this->game_level_info_tags_size(); + for (int i = 0; i < this->game_level_info_tags_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_level_info_tags(i)); + } + + // repeated .bgs.protocol.account.v1.ProgramTag game_status_tags = 9; + total_size += 1 * this->game_status_tags_size(); + for (int i = 0; i < this->game_status_tags_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_status_tags(i)); + } + + // repeated .bgs.protocol.account.v1.RegionTag game_account_tags = 11; + total_size += 1 * this->game_account_tags_size(); + for (int i = 0; i < this->game_account_tags_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account_tags(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 AccountFieldTags::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AccountFieldTags* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AccountFieldTags::MergeFrom(const AccountFieldTags& from) { + GOOGLE_CHECK_NE(&from, this); + game_level_info_tags_.MergeFrom(from.game_level_info_tags_); + game_status_tags_.MergeFrom(from.game_status_tags_); + game_account_tags_.MergeFrom(from.game_account_tags_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_account_level_info_tag()) { + set_account_level_info_tag(from.account_level_info_tag()); + } + if (from.has_privacy_info_tag()) { + set_privacy_info_tag(from.privacy_info_tag()); + } + if (from.has_parental_control_info_tag()) { + set_parental_control_info_tag(from.parental_control_info_tag()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AccountFieldTags::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AccountFieldTags::CopyFrom(const AccountFieldTags& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AccountFieldTags::IsInitialized() const { + + return true; +} + +void AccountFieldTags::Swap(AccountFieldTags* other) { + if (other != this) { + std::swap(account_level_info_tag_, other->account_level_info_tag_); + std::swap(privacy_info_tag_, other->privacy_info_tag_); + std::swap(parental_control_info_tag_, other->parental_control_info_tag_); + game_level_info_tags_.Swap(&other->game_level_info_tags_); + game_status_tags_.Swap(&other->game_status_tags_); + game_account_tags_.Swap(&other->game_account_tags_); + 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 AccountFieldTags::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AccountFieldTags_descriptor_; + metadata.reflection = AccountFieldTags_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GameAccountFieldTags::kGameLevelInfoTagFieldNumber; +const int GameAccountFieldTags::kGameTimeInfoTagFieldNumber; +const int GameAccountFieldTags::kGameStatusTagFieldNumber; +const int GameAccountFieldTags::kRafInfoTagFieldNumber; +#endif // !_MSC_VER + +GameAccountFieldTags::GameAccountFieldTags() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountFieldTags) +} + +void GameAccountFieldTags::InitAsDefaultInstance() { +} + +GameAccountFieldTags::GameAccountFieldTags(const GameAccountFieldTags& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountFieldTags) +} + +void GameAccountFieldTags::SharedCtor() { + _cached_size_ = 0; + game_level_info_tag_ = 0u; + game_time_info_tag_ = 0u; + game_status_tag_ = 0u; + raf_info_tag_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameAccountFieldTags::~GameAccountFieldTags() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountFieldTags) + SharedDtor(); +} + +void GameAccountFieldTags::SharedDtor() { + if (this != default_instance_) { + } +} + +void GameAccountFieldTags::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GameAccountFieldTags::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GameAccountFieldTags_descriptor_; +} + +const GameAccountFieldTags& GameAccountFieldTags::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +GameAccountFieldTags* GameAccountFieldTags::default_instance_ = NULL; + +GameAccountFieldTags* GameAccountFieldTags::New() const { + return new GameAccountFieldTags; +} + +void GameAccountFieldTags::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(game_level_info_tag_, raf_info_tag_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GameAccountFieldTags::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountFieldTags) + 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 game_level_info_tag = 2; + case 2: { + if (tag == 21) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &game_level_info_tag_))); + set_has_game_level_info_tag(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(29)) goto parse_game_time_info_tag; + break; + } + + // optional fixed32 game_time_info_tag = 3; + case 3: { + if (tag == 29) { + parse_game_time_info_tag: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &game_time_info_tag_))); + set_has_game_time_info_tag(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(37)) goto parse_game_status_tag; + break; + } + + // optional fixed32 game_status_tag = 4; + case 4: { + if (tag == 37) { + parse_game_status_tag: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &game_status_tag_))); + set_has_game_status_tag(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(45)) goto parse_raf_info_tag; + break; + } + + // optional fixed32 raf_info_tag = 5; + case 5: { + if (tag == 45) { + parse_raf_info_tag: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &raf_info_tag_))); + set_has_raf_info_tag(); + } 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:bgs.protocol.account.v1.GameAccountFieldTags) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountFieldTags) + return false; +#undef DO_ +} + +void GameAccountFieldTags::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountFieldTags) + // optional fixed32 game_level_info_tag = 2; + if (has_game_level_info_tag()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->game_level_info_tag(), output); + } + + // optional fixed32 game_time_info_tag = 3; + if (has_game_time_info_tag()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->game_time_info_tag(), output); + } + + // optional fixed32 game_status_tag = 4; + if (has_game_status_tag()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->game_status_tag(), output); + } + + // optional fixed32 raf_info_tag = 5; + if (has_raf_info_tag()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->raf_info_tag(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountFieldTags) +} + +::google::protobuf::uint8* GameAccountFieldTags::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountFieldTags) + // optional fixed32 game_level_info_tag = 2; + if (has_game_level_info_tag()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->game_level_info_tag(), target); + } + + // optional fixed32 game_time_info_tag = 3; + if (has_game_time_info_tag()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->game_time_info_tag(), target); + } + + // optional fixed32 game_status_tag = 4; + if (has_game_status_tag()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->game_status_tag(), target); + } + + // optional fixed32 raf_info_tag = 5; + if (has_raf_info_tag()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->raf_info_tag(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountFieldTags) + return target; +} + +int GameAccountFieldTags::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional fixed32 game_level_info_tag = 2; + if (has_game_level_info_tag()) { + total_size += 1 + 4; + } + + // optional fixed32 game_time_info_tag = 3; + if (has_game_time_info_tag()) { + total_size += 1 + 4; + } + + // optional fixed32 game_status_tag = 4; + if (has_game_status_tag()) { + total_size += 1 + 4; + } + + // optional fixed32 raf_info_tag = 5; + if (has_raf_info_tag()) { + 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 GameAccountFieldTags::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GameAccountFieldTags* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GameAccountFieldTags::MergeFrom(const GameAccountFieldTags& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_game_level_info_tag()) { + set_game_level_info_tag(from.game_level_info_tag()); + } + if (from.has_game_time_info_tag()) { + set_game_time_info_tag(from.game_time_info_tag()); + } + if (from.has_game_status_tag()) { + set_game_status_tag(from.game_status_tag()); + } + if (from.has_raf_info_tag()) { + set_raf_info_tag(from.raf_info_tag()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GameAccountFieldTags::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GameAccountFieldTags::CopyFrom(const GameAccountFieldTags& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameAccountFieldTags::IsInitialized() const { + + return true; +} + +void GameAccountFieldTags::Swap(GameAccountFieldTags* other) { + if (other != this) { + std::swap(game_level_info_tag_, other->game_level_info_tag_); + std::swap(game_time_info_tag_, other->game_time_info_tag_); + std::swap(game_status_tag_, other->game_status_tag_); + std::swap(raf_info_tag_, other->raf_info_tag_); + 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 GameAccountFieldTags::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GameAccountFieldTags_descriptor_; + metadata.reflection = GameAccountFieldTags_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AccountFieldOptions::kAllFieldsFieldNumber; +const int AccountFieldOptions::kFieldAccountLevelInfoFieldNumber; +const int AccountFieldOptions::kFieldPrivacyInfoFieldNumber; +const int AccountFieldOptions::kFieldParentalControlInfoFieldNumber; +const int AccountFieldOptions::kFieldGameLevelInfoFieldNumber; +const int AccountFieldOptions::kFieldGameStatusFieldNumber; +const int AccountFieldOptions::kFieldGameAccountsFieldNumber; +#endif // !_MSC_VER + +AccountFieldOptions::AccountFieldOptions() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountFieldOptions) +} + +void AccountFieldOptions::InitAsDefaultInstance() { +} + +AccountFieldOptions::AccountFieldOptions(const AccountFieldOptions& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountFieldOptions) +} + +void AccountFieldOptions::SharedCtor() { + _cached_size_ = 0; + all_fields_ = false; + field_account_level_info_ = false; + field_privacy_info_ = false; + field_parental_control_info_ = false; + field_game_level_info_ = false; + field_game_status_ = false; + field_game_accounts_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AccountFieldOptions::~AccountFieldOptions() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountFieldOptions) + SharedDtor(); +} + +void AccountFieldOptions::SharedDtor() { + if (this != default_instance_) { + } +} + +void AccountFieldOptions::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AccountFieldOptions::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AccountFieldOptions_descriptor_; +} + +const AccountFieldOptions& AccountFieldOptions::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +AccountFieldOptions* AccountFieldOptions::default_instance_ = NULL; + +AccountFieldOptions* AccountFieldOptions::New() const { + return new AccountFieldOptions; +} + +void AccountFieldOptions::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(all_fields_, field_game_accounts_); + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AccountFieldOptions::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountFieldOptions) + 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 all_fields = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &all_fields_))); + set_has_all_fields(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_field_account_level_info; + break; + } + + // optional bool field_account_level_info = 2; + case 2: { + if (tag == 16) { + parse_field_account_level_info: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &field_account_level_info_))); + set_has_field_account_level_info(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_field_privacy_info; + break; + } + + // optional bool field_privacy_info = 3; + case 3: { + if (tag == 24) { + parse_field_privacy_info: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &field_privacy_info_))); + set_has_field_privacy_info(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_field_parental_control_info; + break; + } + + // optional bool field_parental_control_info = 4; + case 4: { + if (tag == 32) { + parse_field_parental_control_info: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &field_parental_control_info_))); + set_has_field_parental_control_info(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_field_game_level_info; + break; + } + + // optional bool field_game_level_info = 6; + case 6: { + if (tag == 48) { + parse_field_game_level_info: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &field_game_level_info_))); + set_has_field_game_level_info(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(56)) goto parse_field_game_status; + break; + } + + // optional bool field_game_status = 7; + case 7: { + if (tag == 56) { + parse_field_game_status: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &field_game_status_))); + set_has_field_game_status(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(64)) goto parse_field_game_accounts; + break; + } + + // optional bool field_game_accounts = 8; + case 8: { + if (tag == 64) { + parse_field_game_accounts: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &field_game_accounts_))); + set_has_field_game_accounts(); + } 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:bgs.protocol.account.v1.AccountFieldOptions) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountFieldOptions) + return false; +#undef DO_ +} + +void AccountFieldOptions::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountFieldOptions) + // optional bool all_fields = 1; + if (has_all_fields()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->all_fields(), output); + } + + // optional bool field_account_level_info = 2; + if (has_field_account_level_info()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->field_account_level_info(), output); + } + + // optional bool field_privacy_info = 3; + if (has_field_privacy_info()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->field_privacy_info(), output); + } + + // optional bool field_parental_control_info = 4; + if (has_field_parental_control_info()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->field_parental_control_info(), output); + } + + // optional bool field_game_level_info = 6; + if (has_field_game_level_info()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->field_game_level_info(), output); + } + + // optional bool field_game_status = 7; + if (has_field_game_status()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->field_game_status(), output); + } + + // optional bool field_game_accounts = 8; + if (has_field_game_accounts()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(8, this->field_game_accounts(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountFieldOptions) +} + +::google::protobuf::uint8* AccountFieldOptions::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountFieldOptions) + // optional bool all_fields = 1; + if (has_all_fields()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->all_fields(), target); + } + + // optional bool field_account_level_info = 2; + if (has_field_account_level_info()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->field_account_level_info(), target); + } + + // optional bool field_privacy_info = 3; + if (has_field_privacy_info()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->field_privacy_info(), target); + } + + // optional bool field_parental_control_info = 4; + if (has_field_parental_control_info()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->field_parental_control_info(), target); + } + + // optional bool field_game_level_info = 6; + if (has_field_game_level_info()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->field_game_level_info(), target); + } + + // optional bool field_game_status = 7; + if (has_field_game_status()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->field_game_status(), target); + } + + // optional bool field_game_accounts = 8; + if (has_field_game_accounts()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(8, this->field_game_accounts(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountFieldOptions) + return target; +} + +int AccountFieldOptions::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional bool all_fields = 1; + if (has_all_fields()) { + total_size += 1 + 1; + } + + // optional bool field_account_level_info = 2; + if (has_field_account_level_info()) { + total_size += 1 + 1; + } + + // optional bool field_privacy_info = 3; + if (has_field_privacy_info()) { + total_size += 1 + 1; + } + + // optional bool field_parental_control_info = 4; + if (has_field_parental_control_info()) { + total_size += 1 + 1; + } + + // optional bool field_game_level_info = 6; + if (has_field_game_level_info()) { + total_size += 1 + 1; + } + + // optional bool field_game_status = 7; + if (has_field_game_status()) { + total_size += 1 + 1; + } + + // optional bool field_game_accounts = 8; + if (has_field_game_accounts()) { + 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 AccountFieldOptions::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AccountFieldOptions* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AccountFieldOptions::MergeFrom(const AccountFieldOptions& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_all_fields()) { + set_all_fields(from.all_fields()); + } + if (from.has_field_account_level_info()) { + set_field_account_level_info(from.field_account_level_info()); + } + if (from.has_field_privacy_info()) { + set_field_privacy_info(from.field_privacy_info()); + } + if (from.has_field_parental_control_info()) { + set_field_parental_control_info(from.field_parental_control_info()); + } + if (from.has_field_game_level_info()) { + set_field_game_level_info(from.field_game_level_info()); + } + if (from.has_field_game_status()) { + set_field_game_status(from.field_game_status()); + } + if (from.has_field_game_accounts()) { + set_field_game_accounts(from.field_game_accounts()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AccountFieldOptions::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AccountFieldOptions::CopyFrom(const AccountFieldOptions& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AccountFieldOptions::IsInitialized() const { + + return true; +} + +void AccountFieldOptions::Swap(AccountFieldOptions* other) { + if (other != this) { + std::swap(all_fields_, other->all_fields_); + std::swap(field_account_level_info_, other->field_account_level_info_); + std::swap(field_privacy_info_, other->field_privacy_info_); + std::swap(field_parental_control_info_, other->field_parental_control_info_); + std::swap(field_game_level_info_, other->field_game_level_info_); + std::swap(field_game_status_, other->field_game_status_); + std::swap(field_game_accounts_, other->field_game_accounts_); + 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 AccountFieldOptions::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AccountFieldOptions_descriptor_; + metadata.reflection = AccountFieldOptions_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GameAccountFieldOptions::kAllFieldsFieldNumber; +const int GameAccountFieldOptions::kFieldGameLevelInfoFieldNumber; +const int GameAccountFieldOptions::kFieldGameTimeInfoFieldNumber; +const int GameAccountFieldOptions::kFieldGameStatusFieldNumber; +const int GameAccountFieldOptions::kFieldRafInfoFieldNumber; +#endif // !_MSC_VER + +GameAccountFieldOptions::GameAccountFieldOptions() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountFieldOptions) +} + +void GameAccountFieldOptions::InitAsDefaultInstance() { +} + +GameAccountFieldOptions::GameAccountFieldOptions(const GameAccountFieldOptions& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountFieldOptions) +} + +void GameAccountFieldOptions::SharedCtor() { + _cached_size_ = 0; + all_fields_ = false; + field_game_level_info_ = false; + field_game_time_info_ = false; + field_game_status_ = false; + field_raf_info_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameAccountFieldOptions::~GameAccountFieldOptions() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountFieldOptions) + SharedDtor(); +} + +void GameAccountFieldOptions::SharedDtor() { + if (this != default_instance_) { + } +} + +void GameAccountFieldOptions::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GameAccountFieldOptions::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GameAccountFieldOptions_descriptor_; +} + +const GameAccountFieldOptions& GameAccountFieldOptions::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +GameAccountFieldOptions* GameAccountFieldOptions::default_instance_ = NULL; + +GameAccountFieldOptions* GameAccountFieldOptions::New() const { + return new GameAccountFieldOptions; +} + +void GameAccountFieldOptions::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(all_fields_, field_raf_info_); + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GameAccountFieldOptions::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountFieldOptions) + 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 all_fields = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &all_fields_))); + set_has_all_fields(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_field_game_level_info; + break; + } + + // optional bool field_game_level_info = 2; + case 2: { + if (tag == 16) { + parse_field_game_level_info: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &field_game_level_info_))); + set_has_field_game_level_info(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_field_game_time_info; + break; + } + + // optional bool field_game_time_info = 3; + case 3: { + if (tag == 24) { + parse_field_game_time_info: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &field_game_time_info_))); + set_has_field_game_time_info(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_field_game_status; + break; + } + + // optional bool field_game_status = 4; + case 4: { + if (tag == 32) { + parse_field_game_status: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &field_game_status_))); + set_has_field_game_status(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_field_raf_info; + break; + } + + // optional bool field_raf_info = 5; + case 5: { + if (tag == 40) { + parse_field_raf_info: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &field_raf_info_))); + set_has_field_raf_info(); + } 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:bgs.protocol.account.v1.GameAccountFieldOptions) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountFieldOptions) + return false; +#undef DO_ +} + +void GameAccountFieldOptions::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountFieldOptions) + // optional bool all_fields = 1; + if (has_all_fields()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->all_fields(), output); + } + + // optional bool field_game_level_info = 2; + if (has_field_game_level_info()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->field_game_level_info(), output); + } + + // optional bool field_game_time_info = 3; + if (has_field_game_time_info()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->field_game_time_info(), output); + } + + // optional bool field_game_status = 4; + if (has_field_game_status()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->field_game_status(), output); + } + + // optional bool field_raf_info = 5; + if (has_field_raf_info()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->field_raf_info(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountFieldOptions) +} + +::google::protobuf::uint8* GameAccountFieldOptions::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountFieldOptions) + // optional bool all_fields = 1; + if (has_all_fields()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->all_fields(), target); + } + + // optional bool field_game_level_info = 2; + if (has_field_game_level_info()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->field_game_level_info(), target); + } + + // optional bool field_game_time_info = 3; + if (has_field_game_time_info()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->field_game_time_info(), target); + } + + // optional bool field_game_status = 4; + if (has_field_game_status()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->field_game_status(), target); + } + + // optional bool field_raf_info = 5; + if (has_field_raf_info()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->field_raf_info(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountFieldOptions) + return target; +} + +int GameAccountFieldOptions::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional bool all_fields = 1; + if (has_all_fields()) { + total_size += 1 + 1; + } + + // optional bool field_game_level_info = 2; + if (has_field_game_level_info()) { + total_size += 1 + 1; + } + + // optional bool field_game_time_info = 3; + if (has_field_game_time_info()) { + total_size += 1 + 1; + } + + // optional bool field_game_status = 4; + if (has_field_game_status()) { + total_size += 1 + 1; + } + + // optional bool field_raf_info = 5; + if (has_field_raf_info()) { + 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 GameAccountFieldOptions::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GameAccountFieldOptions* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GameAccountFieldOptions::MergeFrom(const GameAccountFieldOptions& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_all_fields()) { + set_all_fields(from.all_fields()); + } + if (from.has_field_game_level_info()) { + set_field_game_level_info(from.field_game_level_info()); + } + if (from.has_field_game_time_info()) { + set_field_game_time_info(from.field_game_time_info()); + } + if (from.has_field_game_status()) { + set_field_game_status(from.field_game_status()); + } + if (from.has_field_raf_info()) { + set_field_raf_info(from.field_raf_info()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GameAccountFieldOptions::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GameAccountFieldOptions::CopyFrom(const GameAccountFieldOptions& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameAccountFieldOptions::IsInitialized() const { + + return true; +} + +void GameAccountFieldOptions::Swap(GameAccountFieldOptions* other) { + if (other != this) { + std::swap(all_fields_, other->all_fields_); + std::swap(field_game_level_info_, other->field_game_level_info_); + std::swap(field_game_time_info_, other->field_game_time_info_); + std::swap(field_game_status_, other->field_game_status_); + std::swap(field_raf_info_, other->field_raf_info_); + 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 GameAccountFieldOptions::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GameAccountFieldOptions_descriptor_; + metadata.reflection = GameAccountFieldOptions_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int SubscriberReference::kObjectIdFieldNumber; +const int SubscriberReference::kEntityIdFieldNumber; +const int SubscriberReference::kAccountOptionsFieldNumber; +const int SubscriberReference::kAccountTagsFieldNumber; +const int SubscriberReference::kGameAccountOptionsFieldNumber; +const int SubscriberReference::kGameAccountTagsFieldNumber; +const int SubscriberReference::kSubscriberIdFieldNumber; +#endif // !_MSC_VER + +SubscriberReference::SubscriberReference() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.SubscriberReference) +} + +void SubscriberReference::InitAsDefaultInstance() { + entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + account_options_ = const_cast< ::bgs::protocol::account::v1::AccountFieldOptions*>(&::bgs::protocol::account::v1::AccountFieldOptions::default_instance()); + account_tags_ = const_cast< ::bgs::protocol::account::v1::AccountFieldTags*>(&::bgs::protocol::account::v1::AccountFieldTags::default_instance()); + game_account_options_ = const_cast< ::bgs::protocol::account::v1::GameAccountFieldOptions*>(&::bgs::protocol::account::v1::GameAccountFieldOptions::default_instance()); + game_account_tags_ = const_cast< ::bgs::protocol::account::v1::GameAccountFieldTags*>(&::bgs::protocol::account::v1::GameAccountFieldTags::default_instance()); +} + +SubscriberReference::SubscriberReference(const SubscriberReference& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.SubscriberReference) +} + +void SubscriberReference::SharedCtor() { + _cached_size_ = 0; + object_id_ = GOOGLE_ULONGLONG(0); + entity_id_ = NULL; + account_options_ = NULL; + account_tags_ = NULL; + game_account_options_ = NULL; + game_account_tags_ = NULL; + subscriber_id_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +SubscriberReference::~SubscriberReference() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.SubscriberReference) + SharedDtor(); +} + +void SubscriberReference::SharedDtor() { + if (this != default_instance_) { + delete entity_id_; + delete account_options_; + delete account_tags_; + delete game_account_options_; + delete game_account_tags_; + } +} + +void SubscriberReference::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SubscriberReference::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SubscriberReference_descriptor_; +} + +const SubscriberReference& SubscriberReference::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +SubscriberReference* SubscriberReference::default_instance_ = NULL; + +SubscriberReference* SubscriberReference::New() const { + return new SubscriberReference; +} + +void SubscriberReference::Clear() { + if (_has_bits_[0 / 32] & 127) { + object_id_ = GOOGLE_ULONGLONG(0); + if (has_entity_id()) { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_account_options()) { + if (account_options_ != NULL) account_options_->::bgs::protocol::account::v1::AccountFieldOptions::Clear(); + } + if (has_account_tags()) { + if (account_tags_ != NULL) account_tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear(); + } + if (has_game_account_options()) { + if (game_account_options_ != NULL) game_account_options_->::bgs::protocol::account::v1::GameAccountFieldOptions::Clear(); + } + if (has_game_account_tags()) { + if (game_account_tags_ != NULL) game_account_tags_->::bgs::protocol::account::v1::GameAccountFieldTags::Clear(); + } + subscriber_id_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool SubscriberReference::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.SubscriberReference) + 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 uint64 object_id = 1 [default = 0]; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &object_id_))); + set_has_object_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_entity_id; + break; + } + + // optional .bgs.protocol.EntityId entity_id = 2; + case 2: { + if (tag == 18) { + parse_entity_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_entity_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_account_options; + break; + } + + // optional .bgs.protocol.account.v1.AccountFieldOptions account_options = 3; + case 3: { + if (tag == 26) { + parse_account_options: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account_options())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_account_tags; + break; + } + + // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 4; + case 4: { + if (tag == 34) { + parse_account_tags: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account_tags())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_game_account_options; + break; + } + + // optional .bgs.protocol.account.v1.GameAccountFieldOptions game_account_options = 5; + case 5: { + if (tag == 42) { + parse_game_account_options: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account_options())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_game_account_tags; + break; + } + + // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 6; + case 6: { + if (tag == 50) { + parse_game_account_tags: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account_tags())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(56)) goto parse_subscriber_id; + break; + } + + // optional uint64 subscriber_id = 7 [default = 0]; + case 7: { + if (tag == 56) { + parse_subscriber_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &subscriber_id_))); + set_has_subscriber_id(); + } 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:bgs.protocol.account.v1.SubscriberReference) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.SubscriberReference) + return false; +#undef DO_ +} + +void SubscriberReference::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.SubscriberReference) + // optional uint64 object_id = 1 [default = 0]; + if (has_object_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->object_id(), output); + } + + // optional .bgs.protocol.EntityId entity_id = 2; + if (has_entity_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->entity_id(), output); + } + + // optional .bgs.protocol.account.v1.AccountFieldOptions account_options = 3; + if (has_account_options()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->account_options(), output); + } + + // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 4; + if (has_account_tags()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->account_tags(), output); + } + + // optional .bgs.protocol.account.v1.GameAccountFieldOptions game_account_options = 5; + if (has_game_account_options()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, this->game_account_options(), output); + } + + // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 6; + if (has_game_account_tags()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, this->game_account_tags(), output); + } + + // optional uint64 subscriber_id = 7 [default = 0]; + if (has_subscriber_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(7, this->subscriber_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.SubscriberReference) +} + +::google::protobuf::uint8* SubscriberReference::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.SubscriberReference) + // optional uint64 object_id = 1 [default = 0]; + if (has_object_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->object_id(), target); + } + + // optional .bgs.protocol.EntityId entity_id = 2; + if (has_entity_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->entity_id(), target); + } + + // optional .bgs.protocol.account.v1.AccountFieldOptions account_options = 3; + if (has_account_options()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->account_options(), target); + } + + // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 4; + if (has_account_tags()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->account_tags(), target); + } + + // optional .bgs.protocol.account.v1.GameAccountFieldOptions game_account_options = 5; + if (has_game_account_options()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 5, this->game_account_options(), target); + } + + // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 6; + if (has_game_account_tags()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 6, this->game_account_tags(), target); + } + + // optional uint64 subscriber_id = 7 [default = 0]; + if (has_subscriber_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(7, this->subscriber_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.SubscriberReference) + return target; +} + +int SubscriberReference::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional uint64 object_id = 1 [default = 0]; + if (has_object_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->object_id()); + } + + // optional .bgs.protocol.EntityId entity_id = 2; + if (has_entity_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->entity_id()); + } + + // optional .bgs.protocol.account.v1.AccountFieldOptions account_options = 3; + if (has_account_options()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account_options()); + } + + // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 4; + if (has_account_tags()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account_tags()); + } + + // optional .bgs.protocol.account.v1.GameAccountFieldOptions game_account_options = 5; + if (has_game_account_options()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account_options()); + } + + // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 6; + if (has_game_account_tags()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account_tags()); + } + + // optional uint64 subscriber_id = 7 [default = 0]; + if (has_subscriber_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->subscriber_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void SubscriberReference::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const SubscriberReference* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void SubscriberReference::MergeFrom(const SubscriberReference& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_object_id()) { + set_object_id(from.object_id()); + } + if (from.has_entity_id()) { + mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id()); + } + if (from.has_account_options()) { + mutable_account_options()->::bgs::protocol::account::v1::AccountFieldOptions::MergeFrom(from.account_options()); + } + if (from.has_account_tags()) { + mutable_account_tags()->::bgs::protocol::account::v1::AccountFieldTags::MergeFrom(from.account_tags()); + } + if (from.has_game_account_options()) { + mutable_game_account_options()->::bgs::protocol::account::v1::GameAccountFieldOptions::MergeFrom(from.game_account_options()); + } + if (from.has_game_account_tags()) { + mutable_game_account_tags()->::bgs::protocol::account::v1::GameAccountFieldTags::MergeFrom(from.game_account_tags()); + } + if (from.has_subscriber_id()) { + set_subscriber_id(from.subscriber_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void SubscriberReference::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SubscriberReference::CopyFrom(const SubscriberReference& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SubscriberReference::IsInitialized() const { + + if (has_entity_id()) { + if (!this->entity_id().IsInitialized()) return false; + } + return true; +} + +void SubscriberReference::Swap(SubscriberReference* other) { + if (other != this) { + std::swap(object_id_, other->object_id_); + std::swap(entity_id_, other->entity_id_); + std::swap(account_options_, other->account_options_); + std::swap(account_tags_, other->account_tags_); + std::swap(game_account_options_, other->game_account_options_); + std::swap(game_account_tags_, other->game_account_tags_); + std::swap(subscriber_id_, other->subscriber_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata SubscriberReference::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SubscriberReference_descriptor_; + metadata.reflection = SubscriberReference_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AccountLevelInfo::kLicensesFieldNumber; +const int AccountLevelInfo::kDefaultCurrencyFieldNumber; +const int AccountLevelInfo::kCountryFieldNumber; +const int AccountLevelInfo::kPreferredRegionFieldNumber; +const int AccountLevelInfo::kFullNameFieldNumber; +const int AccountLevelInfo::kBattleTagFieldNumber; +const int AccountLevelInfo::kMutedFieldNumber; +const int AccountLevelInfo::kManualReviewFieldNumber; +const int AccountLevelInfo::kAccountPaidAnyFieldNumber; +const int AccountLevelInfo::kIdentityCheckStatusFieldNumber; +const int AccountLevelInfo::kEmailFieldNumber; +#endif // !_MSC_VER + +AccountLevelInfo::AccountLevelInfo() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountLevelInfo) +} + +void AccountLevelInfo::InitAsDefaultInstance() { +} + +AccountLevelInfo::AccountLevelInfo(const AccountLevelInfo& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountLevelInfo) +} + +void AccountLevelInfo::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + default_currency_ = 0u; + country_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + preferred_region_ = 0u; + full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + muted_ = false; + manual_review_ = false; + account_paid_any_ = false; + identity_check_status_ = 0; + email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AccountLevelInfo::~AccountLevelInfo() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountLevelInfo) + SharedDtor(); +} + +void AccountLevelInfo::SharedDtor() { + if (country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete country_; + } + if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete full_name_; + } + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete battle_tag_; + } + if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete email_; + } + if (this != default_instance_) { + } +} + +void AccountLevelInfo::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AccountLevelInfo::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AccountLevelInfo_descriptor_; +} + +const AccountLevelInfo& AccountLevelInfo::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +AccountLevelInfo* AccountLevelInfo::default_instance_ = NULL; + +AccountLevelInfo* AccountLevelInfo::New() const { + return new AccountLevelInfo; +} + +void AccountLevelInfo::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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] & 254) { + ZR_(default_currency_, preferred_region_); + ZR_(muted_, manual_review_); + if (has_country()) { + if (country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + country_->clear(); + } + } + if (has_full_name()) { + if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + full_name_->clear(); + } + } + if (has_battle_tag()) { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_->clear(); + } + } + } + if (_has_bits_[8 / 32] & 1792) { + ZR_(account_paid_any_, identity_check_status_); + if (has_email()) { + if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_->clear(); + } + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + licenses_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AccountLevelInfo::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountLevelInfo) + 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 .bgs.protocol.account.v1.AccountLicense licenses = 3; + case 3: { + if (tag == 26) { + parse_licenses: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_licenses())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_licenses; + if (input->ExpectTag(37)) goto parse_default_currency; + break; + } + + // optional fixed32 default_currency = 4; + case 4: { + if (tag == 37) { + parse_default_currency: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &default_currency_))); + set_has_default_currency(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_country; + break; + } + + // optional string country = 5; + case 5: { + if (tag == 42) { + parse_country: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_country())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->country().data(), this->country().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "country"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_preferred_region; + break; + } + + // optional uint32 preferred_region = 6; + case 6: { + if (tag == 48) { + parse_preferred_region: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &preferred_region_))); + set_has_preferred_region(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(58)) goto parse_full_name; + break; + } + + // optional string full_name = 7; + case 7: { + if (tag == 58) { + parse_full_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_full_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->full_name().data(), this->full_name().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "full_name"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(66)) goto parse_battle_tag; + break; + } + + // optional string battle_tag = 8; + case 8: { + if (tag == 66) { + parse_battle_tag: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_battle_tag())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->battle_tag().data(), this->battle_tag().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "battle_tag"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(72)) goto parse_muted; + break; + } + + // optional bool muted = 9; + case 9: { + if (tag == 72) { + parse_muted: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &muted_))); + set_has_muted(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(80)) goto parse_manual_review; + break; + } + + // optional bool manual_review = 10; + case 10: { + if (tag == 80) { + parse_manual_review: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &manual_review_))); + set_has_manual_review(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(88)) goto parse_account_paid_any; + break; + } + + // optional bool account_paid_any = 11; + case 11: { + if (tag == 88) { + parse_account_paid_any: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &account_paid_any_))); + set_has_account_paid_any(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(96)) goto parse_identity_check_status; + break; + } + + // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 12; + case 12: { + if (tag == 96) { + parse_identity_check_status: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::bgs::protocol::account::v1::IdentityVerificationStatus_IsValid(value)) { + set_identity_check_status(static_cast< ::bgs::protocol::account::v1::IdentityVerificationStatus >(value)); + } else { + mutable_unknown_fields()->AddVarint(12, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(106)) goto parse_email; + break; + } + + // optional string email = 13; + case 13: { + if (tag == 106) { + parse_email: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_email())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->email().data(), this->email().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "email"); + } 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:bgs.protocol.account.v1.AccountLevelInfo) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountLevelInfo) + return false; +#undef DO_ +} + +void AccountLevelInfo::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountLevelInfo) + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 3; + for (int i = 0; i < this->licenses_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->licenses(i), output); + } + + // optional fixed32 default_currency = 4; + if (has_default_currency()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->default_currency(), output); + } + + // optional string country = 5; + if (has_country()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->country().data(), this->country().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "country"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 5, this->country(), output); + } + + // optional uint32 preferred_region = 6; + if (has_preferred_region()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->preferred_region(), output); + } + + // optional string full_name = 7; + if (has_full_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->full_name().data(), this->full_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "full_name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 7, this->full_name(), output); + } + + // optional string battle_tag = 8; + if (has_battle_tag()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->battle_tag().data(), this->battle_tag().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "battle_tag"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 8, this->battle_tag(), output); + } + + // optional bool muted = 9; + if (has_muted()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(9, this->muted(), output); + } + + // optional bool manual_review = 10; + if (has_manual_review()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(10, this->manual_review(), output); + } + + // optional bool account_paid_any = 11; + if (has_account_paid_any()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(11, this->account_paid_any(), output); + } + + // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 12; + if (has_identity_check_status()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 12, this->identity_check_status(), output); + } + + // optional string email = 13; + if (has_email()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->email().data(), this->email().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "email"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 13, this->email(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountLevelInfo) +} + +::google::protobuf::uint8* AccountLevelInfo::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountLevelInfo) + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 3; + for (int i = 0; i < this->licenses_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->licenses(i), target); + } + + // optional fixed32 default_currency = 4; + if (has_default_currency()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->default_currency(), target); + } + + // optional string country = 5; + if (has_country()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->country().data(), this->country().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "country"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 5, this->country(), target); + } + + // optional uint32 preferred_region = 6; + if (has_preferred_region()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->preferred_region(), target); + } + + // optional string full_name = 7; + if (has_full_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->full_name().data(), this->full_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "full_name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 7, this->full_name(), target); + } + + // optional string battle_tag = 8; + if (has_battle_tag()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->battle_tag().data(), this->battle_tag().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "battle_tag"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 8, this->battle_tag(), target); + } + + // optional bool muted = 9; + if (has_muted()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(9, this->muted(), target); + } + + // optional bool manual_review = 10; + if (has_manual_review()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(10, this->manual_review(), target); + } + + // optional bool account_paid_any = 11; + if (has_account_paid_any()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(11, this->account_paid_any(), target); + } + + // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 12; + if (has_identity_check_status()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 12, this->identity_check_status(), target); + } + + // optional string email = 13; + if (has_email()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->email().data(), this->email().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "email"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 13, this->email(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountLevelInfo) + return target; +} + +int AccountLevelInfo::ByteSize() const { + int total_size = 0; + + if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) { + // optional fixed32 default_currency = 4; + if (has_default_currency()) { + total_size += 1 + 4; + } + + // optional string country = 5; + if (has_country()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->country()); + } + + // optional uint32 preferred_region = 6; + if (has_preferred_region()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->preferred_region()); + } + + // optional string full_name = 7; + if (has_full_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->full_name()); + } + + // optional string battle_tag = 8; + if (has_battle_tag()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->battle_tag()); + } + + // optional bool muted = 9; + if (has_muted()) { + total_size += 1 + 1; + } + + // optional bool manual_review = 10; + if (has_manual_review()) { + total_size += 1 + 1; + } + + } + if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + // optional bool account_paid_any = 11; + if (has_account_paid_any()) { + total_size += 1 + 1; + } + + // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 12; + if (has_identity_check_status()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->identity_check_status()); + } + + // optional string email = 13; + if (has_email()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->email()); + } + + } + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 3; + total_size += 1 * this->licenses_size(); + for (int i = 0; i < this->licenses_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->licenses(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 AccountLevelInfo::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AccountLevelInfo* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AccountLevelInfo::MergeFrom(const AccountLevelInfo& from) { + GOOGLE_CHECK_NE(&from, this); + licenses_.MergeFrom(from.licenses_); + if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) { + if (from.has_default_currency()) { + set_default_currency(from.default_currency()); + } + if (from.has_country()) { + set_country(from.country()); + } + if (from.has_preferred_region()) { + set_preferred_region(from.preferred_region()); + } + if (from.has_full_name()) { + set_full_name(from.full_name()); + } + if (from.has_battle_tag()) { + set_battle_tag(from.battle_tag()); + } + if (from.has_muted()) { + set_muted(from.muted()); + } + if (from.has_manual_review()) { + set_manual_review(from.manual_review()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from.has_account_paid_any()) { + set_account_paid_any(from.account_paid_any()); + } + if (from.has_identity_check_status()) { + set_identity_check_status(from.identity_check_status()); + } + if (from.has_email()) { + set_email(from.email()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AccountLevelInfo::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AccountLevelInfo::CopyFrom(const AccountLevelInfo& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AccountLevelInfo::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->licenses())) return false; + return true; +} + +void AccountLevelInfo::Swap(AccountLevelInfo* other) { + if (other != this) { + licenses_.Swap(&other->licenses_); + std::swap(default_currency_, other->default_currency_); + std::swap(country_, other->country_); + std::swap(preferred_region_, other->preferred_region_); + std::swap(full_name_, other->full_name_); + std::swap(battle_tag_, other->battle_tag_); + std::swap(muted_, other->muted_); + std::swap(manual_review_, other->manual_review_); + std::swap(account_paid_any_, other->account_paid_any_); + std::swap(identity_check_status_, other->identity_check_status_); + std::swap(email_, other->email_); + 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 AccountLevelInfo::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AccountLevelInfo_descriptor_; + metadata.reflection = AccountLevelInfo_reflection_; + return metadata; +} + + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* PrivacyInfo_GameInfoPrivacy_descriptor() { + protobuf_AssignDescriptorsOnce(); + return PrivacyInfo_GameInfoPrivacy_descriptor_; +} +bool PrivacyInfo_GameInfoPrivacy_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#ifndef _MSC_VER +const PrivacyInfo_GameInfoPrivacy PrivacyInfo::PRIVACY_ME; +const PrivacyInfo_GameInfoPrivacy PrivacyInfo::PRIVACY_FRIENDS; +const PrivacyInfo_GameInfoPrivacy PrivacyInfo::PRIVACY_EVERYONE; +const PrivacyInfo_GameInfoPrivacy PrivacyInfo::GameInfoPrivacy_MIN; +const PrivacyInfo_GameInfoPrivacy PrivacyInfo::GameInfoPrivacy_MAX; +const int PrivacyInfo::GameInfoPrivacy_ARRAYSIZE; +#endif // _MSC_VER +#ifndef _MSC_VER +const int PrivacyInfo::kIsUsingRidFieldNumber; +const int PrivacyInfo::kIsRealIdVisibleForViewFriendsFieldNumber; +const int PrivacyInfo::kIsHiddenFromFriendFinderFieldNumber; +const int PrivacyInfo::kGameInfoPrivacyFieldNumber; +#endif // !_MSC_VER + +PrivacyInfo::PrivacyInfo() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.PrivacyInfo) +} + +void PrivacyInfo::InitAsDefaultInstance() { +} + +PrivacyInfo::PrivacyInfo(const PrivacyInfo& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.PrivacyInfo) +} + +void PrivacyInfo::SharedCtor() { + _cached_size_ = 0; + is_using_rid_ = false; + is_real_id_visible_for_view_friends_ = false; + is_hidden_from_friend_finder_ = false; + game_info_privacy_ = 1; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +PrivacyInfo::~PrivacyInfo() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.PrivacyInfo) + SharedDtor(); +} + +void PrivacyInfo::SharedDtor() { + if (this != default_instance_) { + } +} + +void PrivacyInfo::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* PrivacyInfo::descriptor() { + protobuf_AssignDescriptorsOnce(); + return PrivacyInfo_descriptor_; +} + +const PrivacyInfo& PrivacyInfo::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +PrivacyInfo* PrivacyInfo::default_instance_ = NULL; + +PrivacyInfo* PrivacyInfo::New() const { + return new PrivacyInfo; +} + +void PrivacyInfo::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(is_using_rid_, is_hidden_from_friend_finder_); + game_info_privacy_ = 1; + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool PrivacyInfo::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.PrivacyInfo) + 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_using_rid = 3; + case 3: { + if (tag == 24) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_using_rid_))); + set_has_is_using_rid(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_is_real_id_visible_for_view_friends; + break; + } + + // optional bool is_real_id_visible_for_view_friends = 4; + case 4: { + if (tag == 32) { + parse_is_real_id_visible_for_view_friends: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_real_id_visible_for_view_friends_))); + set_has_is_real_id_visible_for_view_friends(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_is_hidden_from_friend_finder; + break; + } + + // optional bool is_hidden_from_friend_finder = 5; + case 5: { + if (tag == 40) { + parse_is_hidden_from_friend_finder: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_hidden_from_friend_finder_))); + set_has_is_hidden_from_friend_finder(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_game_info_privacy; + break; + } + + // optional .bgs.protocol.account.v1.PrivacyInfo.GameInfoPrivacy game_info_privacy = 6 [default = PRIVACY_FRIENDS]; + case 6: { + if (tag == 48) { + parse_game_info_privacy: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy_IsValid(value)) { + set_game_info_privacy(static_cast< ::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy >(value)); + } else { + mutable_unknown_fields()->AddVarint(6, 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:bgs.protocol.account.v1.PrivacyInfo) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.PrivacyInfo) + return false; +#undef DO_ +} + +void PrivacyInfo::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.PrivacyInfo) + // optional bool is_using_rid = 3; + if (has_is_using_rid()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->is_using_rid(), output); + } + + // optional bool is_real_id_visible_for_view_friends = 4; + if (has_is_real_id_visible_for_view_friends()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->is_real_id_visible_for_view_friends(), output); + } + + // optional bool is_hidden_from_friend_finder = 5; + if (has_is_hidden_from_friend_finder()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->is_hidden_from_friend_finder(), output); + } + + // optional .bgs.protocol.account.v1.PrivacyInfo.GameInfoPrivacy game_info_privacy = 6 [default = PRIVACY_FRIENDS]; + if (has_game_info_privacy()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 6, this->game_info_privacy(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.PrivacyInfo) +} + +::google::protobuf::uint8* PrivacyInfo::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.PrivacyInfo) + // optional bool is_using_rid = 3; + if (has_is_using_rid()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->is_using_rid(), target); + } + + // optional bool is_real_id_visible_for_view_friends = 4; + if (has_is_real_id_visible_for_view_friends()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->is_real_id_visible_for_view_friends(), target); + } + + // optional bool is_hidden_from_friend_finder = 5; + if (has_is_hidden_from_friend_finder()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->is_hidden_from_friend_finder(), target); + } + + // optional .bgs.protocol.account.v1.PrivacyInfo.GameInfoPrivacy game_info_privacy = 6 [default = PRIVACY_FRIENDS]; + if (has_game_info_privacy()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 6, this->game_info_privacy(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.PrivacyInfo) + return target; +} + +int PrivacyInfo::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional bool is_using_rid = 3; + if (has_is_using_rid()) { + total_size += 1 + 1; + } + + // optional bool is_real_id_visible_for_view_friends = 4; + if (has_is_real_id_visible_for_view_friends()) { + total_size += 1 + 1; + } + + // optional bool is_hidden_from_friend_finder = 5; + if (has_is_hidden_from_friend_finder()) { + total_size += 1 + 1; + } + + // optional .bgs.protocol.account.v1.PrivacyInfo.GameInfoPrivacy game_info_privacy = 6 [default = PRIVACY_FRIENDS]; + if (has_game_info_privacy()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->game_info_privacy()); + } + + } + 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 PrivacyInfo::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const PrivacyInfo* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void PrivacyInfo::MergeFrom(const PrivacyInfo& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_is_using_rid()) { + set_is_using_rid(from.is_using_rid()); + } + if (from.has_is_real_id_visible_for_view_friends()) { + set_is_real_id_visible_for_view_friends(from.is_real_id_visible_for_view_friends()); + } + if (from.has_is_hidden_from_friend_finder()) { + set_is_hidden_from_friend_finder(from.is_hidden_from_friend_finder()); + } + if (from.has_game_info_privacy()) { + set_game_info_privacy(from.game_info_privacy()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void PrivacyInfo::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void PrivacyInfo::CopyFrom(const PrivacyInfo& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PrivacyInfo::IsInitialized() const { + + return true; +} + +void PrivacyInfo::Swap(PrivacyInfo* other) { + if (other != this) { + std::swap(is_using_rid_, other->is_using_rid_); + std::swap(is_real_id_visible_for_view_friends_, other->is_real_id_visible_for_view_friends_); + std::swap(is_hidden_from_friend_finder_, other->is_hidden_from_friend_finder_); + std::swap(game_info_privacy_, other->game_info_privacy_); + 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 PrivacyInfo::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = PrivacyInfo_descriptor_; + metadata.reflection = PrivacyInfo_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ParentalControlInfo::kTimezoneFieldNumber; +const int ParentalControlInfo::kMinutesPerDayFieldNumber; +const int ParentalControlInfo::kMinutesPerWeekFieldNumber; +const int ParentalControlInfo::kCanReceiveVoiceFieldNumber; +const int ParentalControlInfo::kCanSendVoiceFieldNumber; +const int ParentalControlInfo::kPlayScheduleFieldNumber; +#endif // !_MSC_VER + +ParentalControlInfo::ParentalControlInfo() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.ParentalControlInfo) +} + +void ParentalControlInfo::InitAsDefaultInstance() { +} + +ParentalControlInfo::ParentalControlInfo(const ParentalControlInfo& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.ParentalControlInfo) +} + +void ParentalControlInfo::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + timezone_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + minutes_per_day_ = 0u; + minutes_per_week_ = 0u; + can_receive_voice_ = false; + can_send_voice_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ParentalControlInfo::~ParentalControlInfo() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.ParentalControlInfo) + SharedDtor(); +} + +void ParentalControlInfo::SharedDtor() { + if (timezone_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete timezone_; + } + if (this != default_instance_) { + } +} + +void ParentalControlInfo::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ParentalControlInfo::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ParentalControlInfo_descriptor_; +} + +const ParentalControlInfo& ParentalControlInfo::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +ParentalControlInfo* ParentalControlInfo::default_instance_ = NULL; + +ParentalControlInfo* ParentalControlInfo::New() const { + return new ParentalControlInfo; +} + +void ParentalControlInfo::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(minutes_per_day_, minutes_per_week_); + ZR_(can_receive_voice_, can_send_voice_); + if (has_timezone()) { + if (timezone_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + timezone_->clear(); + } + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + play_schedule_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ParentalControlInfo::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.ParentalControlInfo) + 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 timezone = 3; + case 3: { + if (tag == 26) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_timezone())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->timezone().data(), this->timezone().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "timezone"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_minutes_per_day; + break; + } + + // optional uint32 minutes_per_day = 4; + case 4: { + if (tag == 32) { + parse_minutes_per_day: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &minutes_per_day_))); + set_has_minutes_per_day(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_minutes_per_week; + break; + } + + // optional uint32 minutes_per_week = 5; + case 5: { + if (tag == 40) { + parse_minutes_per_week: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &minutes_per_week_))); + set_has_minutes_per_week(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_can_receive_voice; + break; + } + + // optional bool can_receive_voice = 6; + case 6: { + if (tag == 48) { + parse_can_receive_voice: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &can_receive_voice_))); + set_has_can_receive_voice(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(56)) goto parse_can_send_voice; + break; + } + + // optional bool can_send_voice = 7; + case 7: { + if (tag == 56) { + parse_can_send_voice: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &can_send_voice_))); + set_has_can_send_voice(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(64)) goto parse_play_schedule; + break; + } + + // repeated bool play_schedule = 8; + case 8: { + if (tag == 64) { + parse_play_schedule: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + 1, 64, input, this->mutable_play_schedule()))); + } else if (tag == 66) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, this->mutable_play_schedule()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(64)) goto parse_play_schedule; + 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:bgs.protocol.account.v1.ParentalControlInfo) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.ParentalControlInfo) + return false; +#undef DO_ +} + +void ParentalControlInfo::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.ParentalControlInfo) + // optional string timezone = 3; + if (has_timezone()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->timezone().data(), this->timezone().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "timezone"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->timezone(), output); + } + + // optional uint32 minutes_per_day = 4; + if (has_minutes_per_day()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->minutes_per_day(), output); + } + + // optional uint32 minutes_per_week = 5; + if (has_minutes_per_week()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->minutes_per_week(), output); + } + + // optional bool can_receive_voice = 6; + if (has_can_receive_voice()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->can_receive_voice(), output); + } + + // optional bool can_send_voice = 7; + if (has_can_send_voice()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->can_send_voice(), output); + } + + // repeated bool play_schedule = 8; + for (int i = 0; i < this->play_schedule_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteBool( + 8, this->play_schedule(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.ParentalControlInfo) +} + +::google::protobuf::uint8* ParentalControlInfo::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.ParentalControlInfo) + // optional string timezone = 3; + if (has_timezone()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->timezone().data(), this->timezone().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "timezone"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->timezone(), target); + } + + // optional uint32 minutes_per_day = 4; + if (has_minutes_per_day()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->minutes_per_day(), target); + } + + // optional uint32 minutes_per_week = 5; + if (has_minutes_per_week()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->minutes_per_week(), target); + } + + // optional bool can_receive_voice = 6; + if (has_can_receive_voice()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->can_receive_voice(), target); + } + + // optional bool can_send_voice = 7; + if (has_can_send_voice()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->can_send_voice(), target); + } + + // repeated bool play_schedule = 8; + for (int i = 0; i < this->play_schedule_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteBoolToArray(8, this->play_schedule(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.ParentalControlInfo) + return target; +} + +int ParentalControlInfo::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional string timezone = 3; + if (has_timezone()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->timezone()); + } + + // optional uint32 minutes_per_day = 4; + if (has_minutes_per_day()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->minutes_per_day()); + } + + // optional uint32 minutes_per_week = 5; + if (has_minutes_per_week()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->minutes_per_week()); + } + + // optional bool can_receive_voice = 6; + if (has_can_receive_voice()) { + total_size += 1 + 1; + } + + // optional bool can_send_voice = 7; + if (has_can_send_voice()) { + total_size += 1 + 1; + } + + } + // repeated bool play_schedule = 8; + { + int data_size = 0; + data_size = 1 * this->play_schedule_size(); + total_size += 1 * this->play_schedule_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 ParentalControlInfo::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ParentalControlInfo* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ParentalControlInfo::MergeFrom(const ParentalControlInfo& from) { + GOOGLE_CHECK_NE(&from, this); + play_schedule_.MergeFrom(from.play_schedule_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_timezone()) { + set_timezone(from.timezone()); + } + if (from.has_minutes_per_day()) { + set_minutes_per_day(from.minutes_per_day()); + } + if (from.has_minutes_per_week()) { + set_minutes_per_week(from.minutes_per_week()); + } + if (from.has_can_receive_voice()) { + set_can_receive_voice(from.can_receive_voice()); + } + if (from.has_can_send_voice()) { + set_can_send_voice(from.can_send_voice()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ParentalControlInfo::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ParentalControlInfo::CopyFrom(const ParentalControlInfo& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ParentalControlInfo::IsInitialized() const { + + return true; +} + +void ParentalControlInfo::Swap(ParentalControlInfo* other) { + if (other != this) { + std::swap(timezone_, other->timezone_); + std::swap(minutes_per_day_, other->minutes_per_day_); + std::swap(minutes_per_week_, other->minutes_per_week_); + std::swap(can_receive_voice_, other->can_receive_voice_); + std::swap(can_send_voice_, other->can_send_voice_); + play_schedule_.Swap(&other->play_schedule_); + 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 ParentalControlInfo::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ParentalControlInfo_descriptor_; + metadata.reflection = ParentalControlInfo_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GameLevelInfo::kIsTrialFieldNumber; +const int GameLevelInfo::kIsLifetimeFieldNumber; +const int GameLevelInfo::kIsRestrictedFieldNumber; +const int GameLevelInfo::kIsBetaFieldNumber; +const int GameLevelInfo::kNameFieldNumber; +const int GameLevelInfo::kProgramFieldNumber; +const int GameLevelInfo::kLicensesFieldNumber; +const int GameLevelInfo::kRealmPermissionsFieldNumber; +#endif // !_MSC_VER + +GameLevelInfo::GameLevelInfo() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameLevelInfo) +} + +void GameLevelInfo::InitAsDefaultInstance() { +} + +GameLevelInfo::GameLevelInfo(const GameLevelInfo& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameLevelInfo) +} + +void GameLevelInfo::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + is_trial_ = false; + is_lifetime_ = false; + is_restricted_ = false; + is_beta_ = false; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + program_ = 0u; + realm_permissions_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameLevelInfo::~GameLevelInfo() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameLevelInfo) + SharedDtor(); +} + +void GameLevelInfo::SharedDtor() { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete name_; + } + if (this != default_instance_) { + } +} + +void GameLevelInfo::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GameLevelInfo::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GameLevelInfo_descriptor_; +} + +const GameLevelInfo& GameLevelInfo::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +GameLevelInfo* GameLevelInfo::default_instance_ = NULL; + +GameLevelInfo* GameLevelInfo::New() const { + return new GameLevelInfo; +} + +void GameLevelInfo::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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] & 191) { + ZR_(is_trial_, program_); + if (has_name()) { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_->clear(); + } + } + realm_permissions_ = 0u; + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + licenses_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GameLevelInfo::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameLevelInfo) + 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_trial = 4; + case 4: { + if (tag == 32) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_trial_))); + set_has_is_trial(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_is_lifetime; + break; + } + + // optional bool is_lifetime = 5; + case 5: { + if (tag == 40) { + parse_is_lifetime: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_lifetime_))); + set_has_is_lifetime(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_is_restricted; + break; + } + + // optional bool is_restricted = 6; + case 6: { + if (tag == 48) { + parse_is_restricted: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_restricted_))); + set_has_is_restricted(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(56)) goto parse_is_beta; + break; + } + + // optional bool is_beta = 7; + case 7: { + if (tag == 56) { + parse_is_beta: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_beta_))); + set_has_is_beta(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(66)) goto parse_name; + break; + } + + // optional string name = 8; + case 8: { + if (tag == 66) { + 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(77)) goto parse_program; + break; + } + + // optional fixed32 program = 9; + case 9: { + if (tag == 77) { + parse_program: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &program_))); + set_has_program(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(82)) goto parse_licenses; + break; + } + + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 10; + case 10: { + if (tag == 82) { + parse_licenses: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_licenses())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(82)) goto parse_licenses; + if (input->ExpectTag(88)) goto parse_realm_permissions; + break; + } + + // optional uint32 realm_permissions = 11; + case 11: { + if (tag == 88) { + parse_realm_permissions: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &realm_permissions_))); + set_has_realm_permissions(); + } 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:bgs.protocol.account.v1.GameLevelInfo) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameLevelInfo) + return false; +#undef DO_ +} + +void GameLevelInfo::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameLevelInfo) + // optional bool is_trial = 4; + if (has_is_trial()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->is_trial(), output); + } + + // optional bool is_lifetime = 5; + if (has_is_lifetime()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->is_lifetime(), output); + } + + // optional bool is_restricted = 6; + if (has_is_restricted()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->is_restricted(), output); + } + + // optional bool is_beta = 7; + if (has_is_beta()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->is_beta(), output); + } + + // optional string name = 8; + 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( + 8, this->name(), output); + } + + // optional fixed32 program = 9; + if (has_program()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(9, this->program(), output); + } + + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 10; + for (int i = 0; i < this->licenses_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 10, this->licenses(i), output); + } + + // optional uint32 realm_permissions = 11; + if (has_realm_permissions()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(11, this->realm_permissions(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameLevelInfo) +} + +::google::protobuf::uint8* GameLevelInfo::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameLevelInfo) + // optional bool is_trial = 4; + if (has_is_trial()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->is_trial(), target); + } + + // optional bool is_lifetime = 5; + if (has_is_lifetime()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->is_lifetime(), target); + } + + // optional bool is_restricted = 6; + if (has_is_restricted()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->is_restricted(), target); + } + + // optional bool is_beta = 7; + if (has_is_beta()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->is_beta(), target); + } + + // optional string name = 8; + 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( + 8, this->name(), target); + } + + // optional fixed32 program = 9; + if (has_program()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(9, this->program(), target); + } + + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 10; + for (int i = 0; i < this->licenses_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 10, this->licenses(i), target); + } + + // optional uint32 realm_permissions = 11; + if (has_realm_permissions()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(11, this->realm_permissions(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameLevelInfo) + return target; +} + +int GameLevelInfo::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional bool is_trial = 4; + if (has_is_trial()) { + total_size += 1 + 1; + } + + // optional bool is_lifetime = 5; + if (has_is_lifetime()) { + total_size += 1 + 1; + } + + // optional bool is_restricted = 6; + if (has_is_restricted()) { + total_size += 1 + 1; + } + + // optional bool is_beta = 7; + if (has_is_beta()) { + total_size += 1 + 1; + } + + // optional string name = 8; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // optional fixed32 program = 9; + if (has_program()) { + total_size += 1 + 4; + } + + // optional uint32 realm_permissions = 11; + if (has_realm_permissions()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->realm_permissions()); + } + + } + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 10; + total_size += 1 * this->licenses_size(); + for (int i = 0; i < this->licenses_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->licenses(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 GameLevelInfo::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GameLevelInfo* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GameLevelInfo::MergeFrom(const GameLevelInfo& from) { + GOOGLE_CHECK_NE(&from, this); + licenses_.MergeFrom(from.licenses_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_is_trial()) { + set_is_trial(from.is_trial()); + } + if (from.has_is_lifetime()) { + set_is_lifetime(from.is_lifetime()); + } + if (from.has_is_restricted()) { + set_is_restricted(from.is_restricted()); + } + if (from.has_is_beta()) { + set_is_beta(from.is_beta()); + } + if (from.has_name()) { + set_name(from.name()); + } + if (from.has_program()) { + set_program(from.program()); + } + if (from.has_realm_permissions()) { + set_realm_permissions(from.realm_permissions()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GameLevelInfo::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GameLevelInfo::CopyFrom(const GameLevelInfo& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameLevelInfo::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->licenses())) return false; + return true; +} + +void GameLevelInfo::Swap(GameLevelInfo* other) { + if (other != this) { + std::swap(is_trial_, other->is_trial_); + std::swap(is_lifetime_, other->is_lifetime_); + std::swap(is_restricted_, other->is_restricted_); + std::swap(is_beta_, other->is_beta_); + std::swap(name_, other->name_); + std::swap(program_, other->program_); + licenses_.Swap(&other->licenses_); + std::swap(realm_permissions_, other->realm_permissions_); + 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 GameLevelInfo::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GameLevelInfo_descriptor_; + metadata.reflection = GameLevelInfo_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GameTimeInfo::kIsUnlimitedPlayTimeFieldNumber; +const int GameTimeInfo::kPlayTimeExpiresFieldNumber; +const int GameTimeInfo::kIsSubscriptionFieldNumber; +const int GameTimeInfo::kIsRecurringSubscriptionFieldNumber; +#endif // !_MSC_VER + +GameTimeInfo::GameTimeInfo() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameTimeInfo) +} + +void GameTimeInfo::InitAsDefaultInstance() { +} + +GameTimeInfo::GameTimeInfo(const GameTimeInfo& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameTimeInfo) +} + +void GameTimeInfo::SharedCtor() { + _cached_size_ = 0; + is_unlimited_play_time_ = false; + play_time_expires_ = GOOGLE_ULONGLONG(0); + is_subscription_ = false; + is_recurring_subscription_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameTimeInfo::~GameTimeInfo() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameTimeInfo) + SharedDtor(); +} + +void GameTimeInfo::SharedDtor() { + if (this != default_instance_) { + } +} + +void GameTimeInfo::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GameTimeInfo::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GameTimeInfo_descriptor_; +} + +const GameTimeInfo& GameTimeInfo::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +GameTimeInfo* GameTimeInfo::default_instance_ = NULL; + +GameTimeInfo* GameTimeInfo::New() const { + return new GameTimeInfo; +} + +void GameTimeInfo::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(play_time_expires_, is_recurring_subscription_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GameTimeInfo::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameTimeInfo) + 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_unlimited_play_time = 3; + case 3: { + if (tag == 24) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_unlimited_play_time_))); + set_has_is_unlimited_play_time(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_play_time_expires; + break; + } + + // optional uint64 play_time_expires = 5; + case 5: { + if (tag == 40) { + parse_play_time_expires: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &play_time_expires_))); + set_has_play_time_expires(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_is_subscription; + break; + } + + // optional bool is_subscription = 6; + case 6: { + if (tag == 48) { + parse_is_subscription: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_subscription_))); + set_has_is_subscription(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(56)) goto parse_is_recurring_subscription; + break; + } + + // optional bool is_recurring_subscription = 7; + case 7: { + if (tag == 56) { + parse_is_recurring_subscription: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_recurring_subscription_))); + set_has_is_recurring_subscription(); + } 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:bgs.protocol.account.v1.GameTimeInfo) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameTimeInfo) + return false; +#undef DO_ +} + +void GameTimeInfo::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameTimeInfo) + // optional bool is_unlimited_play_time = 3; + if (has_is_unlimited_play_time()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->is_unlimited_play_time(), output); + } + + // optional uint64 play_time_expires = 5; + if (has_play_time_expires()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(5, this->play_time_expires(), output); + } + + // optional bool is_subscription = 6; + if (has_is_subscription()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->is_subscription(), output); + } + + // optional bool is_recurring_subscription = 7; + if (has_is_recurring_subscription()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->is_recurring_subscription(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameTimeInfo) +} + +::google::protobuf::uint8* GameTimeInfo::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameTimeInfo) + // optional bool is_unlimited_play_time = 3; + if (has_is_unlimited_play_time()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->is_unlimited_play_time(), target); + } + + // optional uint64 play_time_expires = 5; + if (has_play_time_expires()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(5, this->play_time_expires(), target); + } + + // optional bool is_subscription = 6; + if (has_is_subscription()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->is_subscription(), target); + } + + // optional bool is_recurring_subscription = 7; + if (has_is_recurring_subscription()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->is_recurring_subscription(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameTimeInfo) + return target; +} + +int GameTimeInfo::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional bool is_unlimited_play_time = 3; + if (has_is_unlimited_play_time()) { + total_size += 1 + 1; + } + + // optional uint64 play_time_expires = 5; + if (has_play_time_expires()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->play_time_expires()); + } + + // optional bool is_subscription = 6; + if (has_is_subscription()) { + total_size += 1 + 1; + } + + // optional bool is_recurring_subscription = 7; + if (has_is_recurring_subscription()) { + 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 GameTimeInfo::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GameTimeInfo* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GameTimeInfo::MergeFrom(const GameTimeInfo& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_is_unlimited_play_time()) { + set_is_unlimited_play_time(from.is_unlimited_play_time()); + } + if (from.has_play_time_expires()) { + set_play_time_expires(from.play_time_expires()); + } + if (from.has_is_subscription()) { + set_is_subscription(from.is_subscription()); + } + if (from.has_is_recurring_subscription()) { + set_is_recurring_subscription(from.is_recurring_subscription()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GameTimeInfo::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GameTimeInfo::CopyFrom(const GameTimeInfo& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameTimeInfo::IsInitialized() const { + + return true; +} + +void GameTimeInfo::Swap(GameTimeInfo* other) { + if (other != this) { + std::swap(is_unlimited_play_time_, other->is_unlimited_play_time_); + std::swap(play_time_expires_, other->play_time_expires_); + std::swap(is_subscription_, other->is_subscription_); + std::swap(is_recurring_subscription_, other->is_recurring_subscription_); + 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 GameTimeInfo::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GameTimeInfo_descriptor_; + metadata.reflection = GameTimeInfo_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GameTimeRemainingInfo::kMinutesRemainingFieldNumber; +const int GameTimeRemainingInfo::kParentalDailyMinutesRemainingFieldNumber; +const int GameTimeRemainingInfo::kParentalWeeklyMinutesRemainingFieldNumber; +const int GameTimeRemainingInfo::kSecondsRemainingUntilKickFieldNumber; +#endif // !_MSC_VER + +GameTimeRemainingInfo::GameTimeRemainingInfo() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameTimeRemainingInfo) +} + +void GameTimeRemainingInfo::InitAsDefaultInstance() { +} + +GameTimeRemainingInfo::GameTimeRemainingInfo(const GameTimeRemainingInfo& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameTimeRemainingInfo) +} + +void GameTimeRemainingInfo::SharedCtor() { + _cached_size_ = 0; + minutes_remaining_ = 0u; + parental_daily_minutes_remaining_ = 0u; + parental_weekly_minutes_remaining_ = 0u; + seconds_remaining_until_kick_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameTimeRemainingInfo::~GameTimeRemainingInfo() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameTimeRemainingInfo) + SharedDtor(); +} + +void GameTimeRemainingInfo::SharedDtor() { + if (this != default_instance_) { + } +} + +void GameTimeRemainingInfo::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GameTimeRemainingInfo::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GameTimeRemainingInfo_descriptor_; +} + +const GameTimeRemainingInfo& GameTimeRemainingInfo::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +GameTimeRemainingInfo* GameTimeRemainingInfo::default_instance_ = NULL; + +GameTimeRemainingInfo* GameTimeRemainingInfo::New() const { + return new GameTimeRemainingInfo; +} + +void GameTimeRemainingInfo::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(minutes_remaining_, seconds_remaining_until_kick_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GameTimeRemainingInfo::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameTimeRemainingInfo) + 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 minutes_remaining = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &minutes_remaining_))); + set_has_minutes_remaining(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_parental_daily_minutes_remaining; + break; + } + + // optional uint32 parental_daily_minutes_remaining = 2; + case 2: { + if (tag == 16) { + parse_parental_daily_minutes_remaining: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &parental_daily_minutes_remaining_))); + set_has_parental_daily_minutes_remaining(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_parental_weekly_minutes_remaining; + break; + } + + // optional uint32 parental_weekly_minutes_remaining = 3; + case 3: { + if (tag == 24) { + parse_parental_weekly_minutes_remaining: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &parental_weekly_minutes_remaining_))); + set_has_parental_weekly_minutes_remaining(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_seconds_remaining_until_kick; + break; + } + + // optional uint32 seconds_remaining_until_kick = 4; + case 4: { + if (tag == 32) { + parse_seconds_remaining_until_kick: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &seconds_remaining_until_kick_))); + set_has_seconds_remaining_until_kick(); + } 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:bgs.protocol.account.v1.GameTimeRemainingInfo) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameTimeRemainingInfo) + return false; +#undef DO_ +} + +void GameTimeRemainingInfo::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameTimeRemainingInfo) + // optional uint32 minutes_remaining = 1; + if (has_minutes_remaining()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->minutes_remaining(), output); + } + + // optional uint32 parental_daily_minutes_remaining = 2; + if (has_parental_daily_minutes_remaining()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->parental_daily_minutes_remaining(), output); + } + + // optional uint32 parental_weekly_minutes_remaining = 3; + if (has_parental_weekly_minutes_remaining()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->parental_weekly_minutes_remaining(), output); + } + + // optional uint32 seconds_remaining_until_kick = 4; + if (has_seconds_remaining_until_kick()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->seconds_remaining_until_kick(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameTimeRemainingInfo) +} + +::google::protobuf::uint8* GameTimeRemainingInfo::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameTimeRemainingInfo) + // optional uint32 minutes_remaining = 1; + if (has_minutes_remaining()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->minutes_remaining(), target); + } + + // optional uint32 parental_daily_minutes_remaining = 2; + if (has_parental_daily_minutes_remaining()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->parental_daily_minutes_remaining(), target); + } + + // optional uint32 parental_weekly_minutes_remaining = 3; + if (has_parental_weekly_minutes_remaining()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->parental_weekly_minutes_remaining(), target); + } + + // optional uint32 seconds_remaining_until_kick = 4; + if (has_seconds_remaining_until_kick()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->seconds_remaining_until_kick(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameTimeRemainingInfo) + return target; +} + +int GameTimeRemainingInfo::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional uint32 minutes_remaining = 1; + if (has_minutes_remaining()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->minutes_remaining()); + } + + // optional uint32 parental_daily_minutes_remaining = 2; + if (has_parental_daily_minutes_remaining()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->parental_daily_minutes_remaining()); + } + + // optional uint32 parental_weekly_minutes_remaining = 3; + if (has_parental_weekly_minutes_remaining()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->parental_weekly_minutes_remaining()); + } + + // optional uint32 seconds_remaining_until_kick = 4; + if (has_seconds_remaining_until_kick()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->seconds_remaining_until_kick()); + } + + } + 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 GameTimeRemainingInfo::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GameTimeRemainingInfo* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GameTimeRemainingInfo::MergeFrom(const GameTimeRemainingInfo& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_minutes_remaining()) { + set_minutes_remaining(from.minutes_remaining()); + } + if (from.has_parental_daily_minutes_remaining()) { + set_parental_daily_minutes_remaining(from.parental_daily_minutes_remaining()); + } + if (from.has_parental_weekly_minutes_remaining()) { + set_parental_weekly_minutes_remaining(from.parental_weekly_minutes_remaining()); + } + if (from.has_seconds_remaining_until_kick()) { + set_seconds_remaining_until_kick(from.seconds_remaining_until_kick()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GameTimeRemainingInfo::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GameTimeRemainingInfo::CopyFrom(const GameTimeRemainingInfo& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameTimeRemainingInfo::IsInitialized() const { + + return true; +} + +void GameTimeRemainingInfo::Swap(GameTimeRemainingInfo* other) { + if (other != this) { + std::swap(minutes_remaining_, other->minutes_remaining_); + std::swap(parental_daily_minutes_remaining_, other->parental_daily_minutes_remaining_); + std::swap(parental_weekly_minutes_remaining_, other->parental_weekly_minutes_remaining_); + std::swap(seconds_remaining_until_kick_, other->seconds_remaining_until_kick_); + 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 GameTimeRemainingInfo::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GameTimeRemainingInfo_descriptor_; + metadata.reflection = GameTimeRemainingInfo_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GameStatus::kIsSuspendedFieldNumber; +const int GameStatus::kIsBannedFieldNumber; +const int GameStatus::kSuspensionExpiresFieldNumber; +const int GameStatus::kProgramFieldNumber; +const int GameStatus::kIsLockedFieldNumber; +const int GameStatus::kIsBamUnlockableFieldNumber; +#endif // !_MSC_VER + +GameStatus::GameStatus() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameStatus) +} + +void GameStatus::InitAsDefaultInstance() { +} + +GameStatus::GameStatus(const GameStatus& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameStatus) +} + +void GameStatus::SharedCtor() { + _cached_size_ = 0; + is_suspended_ = false; + is_banned_ = false; + suspension_expires_ = GOOGLE_ULONGLONG(0); + program_ = 0u; + is_locked_ = false; + is_bam_unlockable_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameStatus::~GameStatus() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameStatus) + SharedDtor(); +} + +void GameStatus::SharedDtor() { + if (this != default_instance_) { + } +} + +void GameStatus::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GameStatus::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GameStatus_descriptor_; +} + +const GameStatus& GameStatus::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +GameStatus* GameStatus::default_instance_ = NULL; + +GameStatus* GameStatus::New() const { + return new GameStatus; +} + +void GameStatus::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(suspension_expires_, program_); + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GameStatus::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameStatus) + 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_suspended = 4; + case 4: { + if (tag == 32) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_suspended_))); + set_has_is_suspended(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_is_banned; + break; + } + + // optional bool is_banned = 5; + case 5: { + if (tag == 40) { + parse_is_banned: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_banned_))); + set_has_is_banned(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_suspension_expires; + break; + } + + // optional uint64 suspension_expires = 6; + case 6: { + if (tag == 48) { + parse_suspension_expires: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &suspension_expires_))); + set_has_suspension_expires(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(61)) goto parse_program; + break; + } + + // optional fixed32 program = 7; + case 7: { + if (tag == 61) { + parse_program: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &program_))); + set_has_program(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(64)) goto parse_is_locked; + break; + } + + // optional bool is_locked = 8; + case 8: { + if (tag == 64) { + parse_is_locked: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_locked_))); + set_has_is_locked(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(72)) goto parse_is_bam_unlockable; + break; + } + + // optional bool is_bam_unlockable = 9; + case 9: { + if (tag == 72) { + parse_is_bam_unlockable: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_bam_unlockable_))); + set_has_is_bam_unlockable(); + } 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:bgs.protocol.account.v1.GameStatus) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameStatus) + return false; +#undef DO_ +} + +void GameStatus::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameStatus) + // optional bool is_suspended = 4; + if (has_is_suspended()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->is_suspended(), output); + } + + // optional bool is_banned = 5; + if (has_is_banned()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->is_banned(), output); + } + + // optional uint64 suspension_expires = 6; + if (has_suspension_expires()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(6, this->suspension_expires(), output); + } + + // optional fixed32 program = 7; + if (has_program()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(7, this->program(), output); + } + + // optional bool is_locked = 8; + if (has_is_locked()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(8, this->is_locked(), output); + } + + // optional bool is_bam_unlockable = 9; + if (has_is_bam_unlockable()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(9, this->is_bam_unlockable(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameStatus) +} + +::google::protobuf::uint8* GameStatus::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameStatus) + // optional bool is_suspended = 4; + if (has_is_suspended()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->is_suspended(), target); + } + + // optional bool is_banned = 5; + if (has_is_banned()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->is_banned(), target); + } + + // optional uint64 suspension_expires = 6; + if (has_suspension_expires()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(6, this->suspension_expires(), target); + } + + // optional fixed32 program = 7; + if (has_program()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(7, this->program(), target); + } + + // optional bool is_locked = 8; + if (has_is_locked()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(8, this->is_locked(), target); + } + + // optional bool is_bam_unlockable = 9; + if (has_is_bam_unlockable()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(9, this->is_bam_unlockable(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameStatus) + return target; +} + +int GameStatus::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional bool is_suspended = 4; + if (has_is_suspended()) { + total_size += 1 + 1; + } + + // optional bool is_banned = 5; + if (has_is_banned()) { + total_size += 1 + 1; + } + + // optional uint64 suspension_expires = 6; + if (has_suspension_expires()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->suspension_expires()); + } + + // optional fixed32 program = 7; + if (has_program()) { + total_size += 1 + 4; + } + + // optional bool is_locked = 8; + if (has_is_locked()) { + total_size += 1 + 1; + } + + // optional bool is_bam_unlockable = 9; + if (has_is_bam_unlockable()) { + 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 GameStatus::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GameStatus* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GameStatus::MergeFrom(const GameStatus& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_is_suspended()) { + set_is_suspended(from.is_suspended()); + } + if (from.has_is_banned()) { + set_is_banned(from.is_banned()); + } + if (from.has_suspension_expires()) { + set_suspension_expires(from.suspension_expires()); + } + if (from.has_program()) { + set_program(from.program()); + } + if (from.has_is_locked()) { + set_is_locked(from.is_locked()); + } + if (from.has_is_bam_unlockable()) { + set_is_bam_unlockable(from.is_bam_unlockable()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GameStatus::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GameStatus::CopyFrom(const GameStatus& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameStatus::IsInitialized() const { + + return true; +} + +void GameStatus::Swap(GameStatus* other) { + if (other != this) { + std::swap(is_suspended_, other->is_suspended_); + std::swap(is_banned_, other->is_banned_); + std::swap(suspension_expires_, other->suspension_expires_); + std::swap(program_, other->program_); + std::swap(is_locked_, other->is_locked_); + std::swap(is_bam_unlockable_, other->is_bam_unlockable_); + 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 GameStatus::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GameStatus_descriptor_; + metadata.reflection = GameStatus_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int RAFInfo::kRafInfoFieldNumber; +#endif // !_MSC_VER + +RAFInfo::RAFInfo() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.RAFInfo) +} + +void RAFInfo::InitAsDefaultInstance() { +} + +RAFInfo::RAFInfo(const RAFInfo& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.RAFInfo) +} + +void RAFInfo::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + raf_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +RAFInfo::~RAFInfo() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.RAFInfo) + SharedDtor(); +} + +void RAFInfo::SharedDtor() { + if (raf_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete raf_info_; + } + if (this != default_instance_) { + } +} + +void RAFInfo::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* RAFInfo::descriptor() { + protobuf_AssignDescriptorsOnce(); + return RAFInfo_descriptor_; +} + +const RAFInfo& RAFInfo::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +RAFInfo* RAFInfo::default_instance_ = NULL; + +RAFInfo* RAFInfo::New() const { + return new RAFInfo; +} + +void RAFInfo::Clear() { + if (has_raf_info()) { + if (raf_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + raf_info_->clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool RAFInfo::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.RAFInfo) + 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 raf_info = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_raf_info())); + } 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:bgs.protocol.account.v1.RAFInfo) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.RAFInfo) + return false; +#undef DO_ +} + +void RAFInfo::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.RAFInfo) + // optional bytes raf_info = 1; + if (has_raf_info()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 1, this->raf_info(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.RAFInfo) +} + +::google::protobuf::uint8* RAFInfo::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.RAFInfo) + // optional bytes raf_info = 1; + if (has_raf_info()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 1, this->raf_info(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.RAFInfo) + return target; +} + +int RAFInfo::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional bytes raf_info = 1; + if (has_raf_info()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->raf_info()); + } + + } + 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 RAFInfo::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const RAFInfo* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void RAFInfo::MergeFrom(const RAFInfo& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_raf_info()) { + set_raf_info(from.raf_info()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void RAFInfo::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RAFInfo::CopyFrom(const RAFInfo& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RAFInfo::IsInitialized() const { + + return true; +} + +void RAFInfo::Swap(RAFInfo* other) { + if (other != this) { + std::swap(raf_info_, other->raf_info_); + 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 RAFInfo::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = RAFInfo_descriptor_; + metadata.reflection = RAFInfo_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GameSessionInfo::kStartTimeFieldNumber; +const int GameSessionInfo::kLocationFieldNumber; +const int GameSessionInfo::kHasBenefactorFieldNumber; +const int GameSessionInfo::kIsUsingIgrFieldNumber; +const int GameSessionInfo::kParentalControlsActiveFieldNumber; +const int GameSessionInfo::kStartTimeSecFieldNumber; +#endif // !_MSC_VER + +GameSessionInfo::GameSessionInfo() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameSessionInfo) +} + +void GameSessionInfo::InitAsDefaultInstance() { + location_ = const_cast< ::bgs::protocol::account::v1::GameSessionLocation*>(&::bgs::protocol::account::v1::GameSessionLocation::default_instance()); +} + +GameSessionInfo::GameSessionInfo(const GameSessionInfo& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameSessionInfo) +} + +void GameSessionInfo::SharedCtor() { + _cached_size_ = 0; + start_time_ = 0u; + location_ = NULL; + has_benefactor_ = false; + is_using_igr_ = false; + parental_controls_active_ = false; + start_time_sec_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameSessionInfo::~GameSessionInfo() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameSessionInfo) + SharedDtor(); +} + +void GameSessionInfo::SharedDtor() { + if (this != default_instance_) { + delete location_; + } +} + +void GameSessionInfo::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GameSessionInfo::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GameSessionInfo_descriptor_; +} + +const GameSessionInfo& GameSessionInfo::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +GameSessionInfo* GameSessionInfo::default_instance_ = NULL; + +GameSessionInfo* GameSessionInfo::New() const { + return new GameSessionInfo; +} + +void GameSessionInfo::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(start_time_, start_time_sec_); + if (has_location()) { + if (location_ != NULL) location_->::bgs::protocol::account::v1::GameSessionLocation::Clear(); + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GameSessionInfo::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameSessionInfo) + 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 start_time = 3 [deprecated = true]; + case 3: { + if (tag == 24) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &start_time_))); + set_has_start_time(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_location; + break; + } + + // optional .bgs.protocol.account.v1.GameSessionLocation location = 4; + case 4: { + if (tag == 34) { + parse_location: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_location())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_has_benefactor; + break; + } + + // optional bool has_benefactor = 5; + case 5: { + if (tag == 40) { + parse_has_benefactor: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &has_benefactor_))); + set_has_has_benefactor(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_is_using_igr; + break; + } + + // optional bool is_using_igr = 6; + case 6: { + if (tag == 48) { + parse_is_using_igr: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_using_igr_))); + set_has_is_using_igr(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(56)) goto parse_parental_controls_active; + break; + } + + // optional bool parental_controls_active = 7; + case 7: { + if (tag == 56) { + parse_parental_controls_active: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &parental_controls_active_))); + set_has_parental_controls_active(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(64)) goto parse_start_time_sec; + break; + } + + // optional uint64 start_time_sec = 8; + case 8: { + if (tag == 64) { + parse_start_time_sec: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &start_time_sec_))); + set_has_start_time_sec(); + } 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:bgs.protocol.account.v1.GameSessionInfo) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameSessionInfo) + return false; +#undef DO_ +} + +void GameSessionInfo::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameSessionInfo) + // optional uint32 start_time = 3 [deprecated = true]; + if (has_start_time()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->start_time(), output); + } + + // optional .bgs.protocol.account.v1.GameSessionLocation location = 4; + if (has_location()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->location(), output); + } + + // optional bool has_benefactor = 5; + if (has_has_benefactor()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->has_benefactor(), output); + } + + // optional bool is_using_igr = 6; + if (has_is_using_igr()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->is_using_igr(), output); + } + + // optional bool parental_controls_active = 7; + if (has_parental_controls_active()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->parental_controls_active(), output); + } + + // optional uint64 start_time_sec = 8; + if (has_start_time_sec()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(8, this->start_time_sec(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameSessionInfo) +} + +::google::protobuf::uint8* GameSessionInfo::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameSessionInfo) + // optional uint32 start_time = 3 [deprecated = true]; + if (has_start_time()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->start_time(), target); + } + + // optional .bgs.protocol.account.v1.GameSessionLocation location = 4; + if (has_location()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->location(), target); + } + + // optional bool has_benefactor = 5; + if (has_has_benefactor()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->has_benefactor(), target); + } + + // optional bool is_using_igr = 6; + if (has_is_using_igr()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->is_using_igr(), target); + } + + // optional bool parental_controls_active = 7; + if (has_parental_controls_active()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->parental_controls_active(), target); + } + + // optional uint64 start_time_sec = 8; + if (has_start_time_sec()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(8, this->start_time_sec(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameSessionInfo) + return target; +} + +int GameSessionInfo::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional uint32 start_time = 3 [deprecated = true]; + if (has_start_time()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->start_time()); + } + + // optional .bgs.protocol.account.v1.GameSessionLocation location = 4; + if (has_location()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->location()); + } + + // optional bool has_benefactor = 5; + if (has_has_benefactor()) { + total_size += 1 + 1; + } + + // optional bool is_using_igr = 6; + if (has_is_using_igr()) { + total_size += 1 + 1; + } + + // optional bool parental_controls_active = 7; + if (has_parental_controls_active()) { + total_size += 1 + 1; + } + + // optional uint64 start_time_sec = 8; + if (has_start_time_sec()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->start_time_sec()); + } + + } + 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 GameSessionInfo::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GameSessionInfo* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GameSessionInfo::MergeFrom(const GameSessionInfo& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_start_time()) { + set_start_time(from.start_time()); + } + if (from.has_location()) { + mutable_location()->::bgs::protocol::account::v1::GameSessionLocation::MergeFrom(from.location()); + } + if (from.has_has_benefactor()) { + set_has_benefactor(from.has_benefactor()); + } + if (from.has_is_using_igr()) { + set_is_using_igr(from.is_using_igr()); + } + if (from.has_parental_controls_active()) { + set_parental_controls_active(from.parental_controls_active()); + } + if (from.has_start_time_sec()) { + set_start_time_sec(from.start_time_sec()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GameSessionInfo::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GameSessionInfo::CopyFrom(const GameSessionInfo& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameSessionInfo::IsInitialized() const { + + return true; +} + +void GameSessionInfo::Swap(GameSessionInfo* other) { + if (other != this) { + std::swap(start_time_, other->start_time_); + std::swap(location_, other->location_); + std::swap(has_benefactor_, other->has_benefactor_); + std::swap(is_using_igr_, other->is_using_igr_); + std::swap(parental_controls_active_, other->parental_controls_active_); + std::swap(start_time_sec_, other->start_time_sec_); + 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 GameSessionInfo::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GameSessionInfo_descriptor_; + metadata.reflection = GameSessionInfo_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GameSessionUpdateInfo::kCaisFieldNumber; +#endif // !_MSC_VER + +GameSessionUpdateInfo::GameSessionUpdateInfo() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameSessionUpdateInfo) +} + +void GameSessionUpdateInfo::InitAsDefaultInstance() { + cais_ = const_cast< ::bgs::protocol::account::v1::CAIS*>(&::bgs::protocol::account::v1::CAIS::default_instance()); +} + +GameSessionUpdateInfo::GameSessionUpdateInfo(const GameSessionUpdateInfo& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameSessionUpdateInfo) +} + +void GameSessionUpdateInfo::SharedCtor() { + _cached_size_ = 0; + cais_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameSessionUpdateInfo::~GameSessionUpdateInfo() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameSessionUpdateInfo) + SharedDtor(); +} + +void GameSessionUpdateInfo::SharedDtor() { + if (this != default_instance_) { + delete cais_; + } +} + +void GameSessionUpdateInfo::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GameSessionUpdateInfo::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GameSessionUpdateInfo_descriptor_; +} + +const GameSessionUpdateInfo& GameSessionUpdateInfo::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +GameSessionUpdateInfo* GameSessionUpdateInfo::default_instance_ = NULL; + +GameSessionUpdateInfo* GameSessionUpdateInfo::New() const { + return new GameSessionUpdateInfo; +} + +void GameSessionUpdateInfo::Clear() { + if (has_cais()) { + if (cais_ != NULL) cais_->::bgs::protocol::account::v1::CAIS::Clear(); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GameSessionUpdateInfo::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameSessionUpdateInfo) + 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 .bgs.protocol.account.v1.CAIS cais = 8; + case 8: { + if (tag == 66) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_cais())); + } 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:bgs.protocol.account.v1.GameSessionUpdateInfo) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameSessionUpdateInfo) + return false; +#undef DO_ +} + +void GameSessionUpdateInfo::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameSessionUpdateInfo) + // optional .bgs.protocol.account.v1.CAIS cais = 8; + if (has_cais()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 8, this->cais(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameSessionUpdateInfo) +} + +::google::protobuf::uint8* GameSessionUpdateInfo::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameSessionUpdateInfo) + // optional .bgs.protocol.account.v1.CAIS cais = 8; + if (has_cais()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 8, this->cais(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameSessionUpdateInfo) + return target; +} + +int GameSessionUpdateInfo::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.account.v1.CAIS cais = 8; + if (has_cais()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->cais()); + } + + } + 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 GameSessionUpdateInfo::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GameSessionUpdateInfo* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GameSessionUpdateInfo::MergeFrom(const GameSessionUpdateInfo& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_cais()) { + mutable_cais()->::bgs::protocol::account::v1::CAIS::MergeFrom(from.cais()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GameSessionUpdateInfo::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GameSessionUpdateInfo::CopyFrom(const GameSessionUpdateInfo& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameSessionUpdateInfo::IsInitialized() const { + + return true; +} + +void GameSessionUpdateInfo::Swap(GameSessionUpdateInfo* other) { + if (other != this) { + std::swap(cais_, other->cais_); + 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 GameSessionUpdateInfo::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GameSessionUpdateInfo_descriptor_; + metadata.reflection = GameSessionUpdateInfo_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GameSessionLocation::kIpAddressFieldNumber; +const int GameSessionLocation::kCountryFieldNumber; +const int GameSessionLocation::kCityFieldNumber; +#endif // !_MSC_VER + +GameSessionLocation::GameSessionLocation() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameSessionLocation) +} + +void GameSessionLocation::InitAsDefaultInstance() { +} + +GameSessionLocation::GameSessionLocation(const GameSessionLocation& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameSessionLocation) +} + +void GameSessionLocation::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + ip_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + country_ = 0u; + city_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameSessionLocation::~GameSessionLocation() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameSessionLocation) + SharedDtor(); +} + +void GameSessionLocation::SharedDtor() { + if (ip_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete ip_address_; + } + if (city_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete city_; + } + if (this != default_instance_) { + } +} + +void GameSessionLocation::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GameSessionLocation::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GameSessionLocation_descriptor_; +} + +const GameSessionLocation& GameSessionLocation::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +GameSessionLocation* GameSessionLocation::default_instance_ = NULL; + +GameSessionLocation* GameSessionLocation::New() const { + return new GameSessionLocation; +} + +void GameSessionLocation::Clear() { + if (_has_bits_[0 / 32] & 7) { + if (has_ip_address()) { + if (ip_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + ip_address_->clear(); + } + } + country_ = 0u; + if (has_city()) { + if (city_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + city_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GameSessionLocation::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameSessionLocation) + 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 ip_address = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_ip_address())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->ip_address().data(), this->ip_address().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "ip_address"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_country; + break; + } + + // optional uint32 country = 2; + case 2: { + if (tag == 16) { + parse_country: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &country_))); + set_has_country(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_city; + break; + } + + // optional string city = 3; + case 3: { + if (tag == 26) { + parse_city: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_city())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->city().data(), this->city().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "city"); + } 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:bgs.protocol.account.v1.GameSessionLocation) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameSessionLocation) + return false; +#undef DO_ +} + +void GameSessionLocation::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameSessionLocation) + // optional string ip_address = 1; + if (has_ip_address()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->ip_address().data(), this->ip_address().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "ip_address"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->ip_address(), output); + } + + // optional uint32 country = 2; + if (has_country()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->country(), output); + } + + // optional string city = 3; + if (has_city()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->city().data(), this->city().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "city"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->city(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameSessionLocation) +} + +::google::protobuf::uint8* GameSessionLocation::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameSessionLocation) + // optional string ip_address = 1; + if (has_ip_address()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->ip_address().data(), this->ip_address().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "ip_address"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->ip_address(), target); + } + + // optional uint32 country = 2; + if (has_country()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->country(), target); + } + + // optional string city = 3; + if (has_city()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->city().data(), this->city().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "city"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->city(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameSessionLocation) + return target; +} + +int GameSessionLocation::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional string ip_address = 1; + if (has_ip_address()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->ip_address()); + } + + // optional uint32 country = 2; + if (has_country()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->country()); + } + + // optional string city = 3; + if (has_city()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->city()); + } + + } + 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 GameSessionLocation::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GameSessionLocation* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GameSessionLocation::MergeFrom(const GameSessionLocation& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_ip_address()) { + set_ip_address(from.ip_address()); + } + if (from.has_country()) { + set_country(from.country()); + } + if (from.has_city()) { + set_city(from.city()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GameSessionLocation::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GameSessionLocation::CopyFrom(const GameSessionLocation& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameSessionLocation::IsInitialized() const { + + return true; +} + +void GameSessionLocation::Swap(GameSessionLocation* other) { + if (other != this) { + std::swap(ip_address_, other->ip_address_); + std::swap(country_, other->country_); + std::swap(city_, other->city_); + 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 GameSessionLocation::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GameSessionLocation_descriptor_; + metadata.reflection = GameSessionLocation_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int CAIS::kPlayedMinutesFieldNumber; +const int CAIS::kRestedMinutesFieldNumber; +const int CAIS::kLastHeardTimeFieldNumber; +#endif // !_MSC_VER + +CAIS::CAIS() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.CAIS) +} + +void CAIS::InitAsDefaultInstance() { +} + +CAIS::CAIS(const CAIS& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.CAIS) +} + +void CAIS::SharedCtor() { + _cached_size_ = 0; + played_minutes_ = 0u; + rested_minutes_ = 0u; + last_heard_time_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CAIS::~CAIS() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.CAIS) + SharedDtor(); +} + +void CAIS::SharedDtor() { + if (this != default_instance_) { + } +} + +void CAIS::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* CAIS::descriptor() { + protobuf_AssignDescriptorsOnce(); + return CAIS_descriptor_; +} + +const CAIS& CAIS::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +CAIS* CAIS::default_instance_ = NULL; + +CAIS* CAIS::New() const { + return new CAIS; +} + +void CAIS::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(played_minutes_, last_heard_time_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool CAIS::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.CAIS) + 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 played_minutes = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &played_minutes_))); + set_has_played_minutes(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_rested_minutes; + break; + } + + // optional uint32 rested_minutes = 2; + case 2: { + if (tag == 16) { + parse_rested_minutes: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &rested_minutes_))); + set_has_rested_minutes(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_last_heard_time; + break; + } + + // optional uint64 last_heard_time = 3; + case 3: { + if (tag == 24) { + parse_last_heard_time: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &last_heard_time_))); + set_has_last_heard_time(); + } 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:bgs.protocol.account.v1.CAIS) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.CAIS) + return false; +#undef DO_ +} + +void CAIS::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.CAIS) + // optional uint32 played_minutes = 1; + if (has_played_minutes()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->played_minutes(), output); + } + + // optional uint32 rested_minutes = 2; + if (has_rested_minutes()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->rested_minutes(), output); + } + + // optional uint64 last_heard_time = 3; + if (has_last_heard_time()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->last_heard_time(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.CAIS) +} + +::google::protobuf::uint8* CAIS::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.CAIS) + // optional uint32 played_minutes = 1; + if (has_played_minutes()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->played_minutes(), target); + } + + // optional uint32 rested_minutes = 2; + if (has_rested_minutes()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->rested_minutes(), target); + } + + // optional uint64 last_heard_time = 3; + if (has_last_heard_time()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->last_heard_time(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.CAIS) + return target; +} + +int CAIS::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional uint32 played_minutes = 1; + if (has_played_minutes()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->played_minutes()); + } + + // optional uint32 rested_minutes = 2; + if (has_rested_minutes()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->rested_minutes()); + } + + // optional uint64 last_heard_time = 3; + if (has_last_heard_time()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->last_heard_time()); + } + + } + 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 CAIS::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const CAIS* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void CAIS::MergeFrom(const CAIS& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_played_minutes()) { + set_played_minutes(from.played_minutes()); + } + if (from.has_rested_minutes()) { + set_rested_minutes(from.rested_minutes()); + } + if (from.has_last_heard_time()) { + set_last_heard_time(from.last_heard_time()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void CAIS::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CAIS::CopyFrom(const CAIS& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CAIS::IsInitialized() const { + + return true; +} + +void CAIS::Swap(CAIS* other) { + if (other != this) { + std::swap(played_minutes_, other->played_minutes_); + std::swap(rested_minutes_, other->rested_minutes_); + std::swap(last_heard_time_, other->last_heard_time_); + 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 CAIS::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = CAIS_descriptor_; + metadata.reflection = CAIS_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GameAccountList::kRegionFieldNumber; +const int GameAccountList::kHandleFieldNumber; +#endif // !_MSC_VER + +GameAccountList::GameAccountList() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountList) +} + +void GameAccountList::InitAsDefaultInstance() { +} + +GameAccountList::GameAccountList(const GameAccountList& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountList) +} + +void GameAccountList::SharedCtor() { + _cached_size_ = 0; + region_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameAccountList::~GameAccountList() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountList) + SharedDtor(); +} + +void GameAccountList::SharedDtor() { + if (this != default_instance_) { + } +} + +void GameAccountList::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GameAccountList::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GameAccountList_descriptor_; +} + +const GameAccountList& GameAccountList::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +GameAccountList* GameAccountList::default_instance_ = NULL; + +GameAccountList* GameAccountList::New() const { + return new GameAccountList; +} + +void GameAccountList::Clear() { + region_ = 0u; + handle_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GameAccountList::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountList) + 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 region = 3; + case 3: { + if (tag == 24) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, ®ion_))); + set_has_region(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_handle; + break; + } + + // repeated .bgs.protocol.account.v1.GameAccountHandle handle = 4; + case 4: { + if (tag == 34) { + parse_handle: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_handle())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_handle; + 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:bgs.protocol.account.v1.GameAccountList) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountList) + return false; +#undef DO_ +} + +void GameAccountList::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountList) + // optional uint32 region = 3; + if (has_region()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->region(), output); + } + + // repeated .bgs.protocol.account.v1.GameAccountHandle handle = 4; + for (int i = 0; i < this->handle_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->handle(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountList) +} + +::google::protobuf::uint8* GameAccountList::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountList) + // optional uint32 region = 3; + if (has_region()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->region(), target); + } + + // repeated .bgs.protocol.account.v1.GameAccountHandle handle = 4; + for (int i = 0; i < this->handle_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->handle(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountList) + return target; +} + +int GameAccountList::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional uint32 region = 3; + if (has_region()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->region()); + } + + } + // repeated .bgs.protocol.account.v1.GameAccountHandle handle = 4; + total_size += 1 * this->handle_size(); + for (int i = 0; i < this->handle_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->handle(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 GameAccountList::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GameAccountList* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GameAccountList::MergeFrom(const GameAccountList& from) { + GOOGLE_CHECK_NE(&from, this); + handle_.MergeFrom(from.handle_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_region()) { + set_region(from.region()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GameAccountList::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GameAccountList::CopyFrom(const GameAccountList& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameAccountList::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->handle())) return false; + return true; +} + +void GameAccountList::Swap(GameAccountList* other) { + if (other != this) { + std::swap(region_, other->region_); + handle_.Swap(&other->handle_); + 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 GameAccountList::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GameAccountList_descriptor_; + metadata.reflection = GameAccountList_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AccountState::kAccountLevelInfoFieldNumber; +const int AccountState::kPrivacyInfoFieldNumber; +const int AccountState::kParentalControlInfoFieldNumber; +const int AccountState::kGameLevelInfoFieldNumber; +const int AccountState::kGameStatusFieldNumber; +const int AccountState::kGameAccountsFieldNumber; +#endif // !_MSC_VER + +AccountState::AccountState() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountState) +} + +void AccountState::InitAsDefaultInstance() { + account_level_info_ = const_cast< ::bgs::protocol::account::v1::AccountLevelInfo*>(&::bgs::protocol::account::v1::AccountLevelInfo::default_instance()); + privacy_info_ = const_cast< ::bgs::protocol::account::v1::PrivacyInfo*>(&::bgs::protocol::account::v1::PrivacyInfo::default_instance()); + parental_control_info_ = const_cast< ::bgs::protocol::account::v1::ParentalControlInfo*>(&::bgs::protocol::account::v1::ParentalControlInfo::default_instance()); +} + +AccountState::AccountState(const AccountState& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountState) +} + +void AccountState::SharedCtor() { + _cached_size_ = 0; + account_level_info_ = NULL; + privacy_info_ = NULL; + parental_control_info_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AccountState::~AccountState() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountState) + SharedDtor(); +} + +void AccountState::SharedDtor() { + if (this != default_instance_) { + delete account_level_info_; + delete privacy_info_; + delete parental_control_info_; + } +} + +void AccountState::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AccountState::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AccountState_descriptor_; +} + +const AccountState& AccountState::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +AccountState* AccountState::default_instance_ = NULL; + +AccountState* AccountState::New() const { + return new AccountState; +} + +void AccountState::Clear() { + if (_has_bits_[0 / 32] & 7) { + if (has_account_level_info()) { + if (account_level_info_ != NULL) account_level_info_->::bgs::protocol::account::v1::AccountLevelInfo::Clear(); + } + if (has_privacy_info()) { + if (privacy_info_ != NULL) privacy_info_->::bgs::protocol::account::v1::PrivacyInfo::Clear(); + } + if (has_parental_control_info()) { + if (parental_control_info_ != NULL) parental_control_info_->::bgs::protocol::account::v1::ParentalControlInfo::Clear(); + } + } + game_level_info_.Clear(); + game_status_.Clear(); + game_accounts_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AccountState::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountState) + 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 .bgs.protocol.account.v1.AccountLevelInfo account_level_info = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account_level_info())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_privacy_info; + break; + } + + // optional .bgs.protocol.account.v1.PrivacyInfo privacy_info = 2; + case 2: { + if (tag == 18) { + parse_privacy_info: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_privacy_info())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_parental_control_info; + break; + } + + // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 3; + case 3: { + if (tag == 26) { + parse_parental_control_info: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_parental_control_info())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_game_level_info; + break; + } + + // repeated .bgs.protocol.account.v1.GameLevelInfo game_level_info = 5; + case 5: { + if (tag == 42) { + parse_game_level_info: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_game_level_info())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_game_level_info; + if (input->ExpectTag(50)) goto parse_game_status; + break; + } + + // repeated .bgs.protocol.account.v1.GameStatus game_status = 6; + case 6: { + if (tag == 50) { + parse_game_status: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_game_status())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_game_status; + if (input->ExpectTag(58)) goto parse_game_accounts; + break; + } + + // repeated .bgs.protocol.account.v1.GameAccountList game_accounts = 7; + case 7: { + if (tag == 58) { + parse_game_accounts: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_game_accounts())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(58)) goto parse_game_accounts; + 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:bgs.protocol.account.v1.AccountState) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountState) + return false; +#undef DO_ +} + +void AccountState::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountState) + // optional .bgs.protocol.account.v1.AccountLevelInfo account_level_info = 1; + if (has_account_level_info()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->account_level_info(), output); + } + + // optional .bgs.protocol.account.v1.PrivacyInfo privacy_info = 2; + if (has_privacy_info()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->privacy_info(), output); + } + + // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 3; + if (has_parental_control_info()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->parental_control_info(), output); + } + + // repeated .bgs.protocol.account.v1.GameLevelInfo game_level_info = 5; + for (int i = 0; i < this->game_level_info_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, this->game_level_info(i), output); + } + + // repeated .bgs.protocol.account.v1.GameStatus game_status = 6; + for (int i = 0; i < this->game_status_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, this->game_status(i), output); + } + + // repeated .bgs.protocol.account.v1.GameAccountList game_accounts = 7; + for (int i = 0; i < this->game_accounts_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 7, this->game_accounts(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountState) +} + +::google::protobuf::uint8* AccountState::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountState) + // optional .bgs.protocol.account.v1.AccountLevelInfo account_level_info = 1; + if (has_account_level_info()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->account_level_info(), target); + } + + // optional .bgs.protocol.account.v1.PrivacyInfo privacy_info = 2; + if (has_privacy_info()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->privacy_info(), target); + } + + // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 3; + if (has_parental_control_info()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->parental_control_info(), target); + } + + // repeated .bgs.protocol.account.v1.GameLevelInfo game_level_info = 5; + for (int i = 0; i < this->game_level_info_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 5, this->game_level_info(i), target); + } + + // repeated .bgs.protocol.account.v1.GameStatus game_status = 6; + for (int i = 0; i < this->game_status_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 6, this->game_status(i), target); + } + + // repeated .bgs.protocol.account.v1.GameAccountList game_accounts = 7; + for (int i = 0; i < this->game_accounts_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 7, this->game_accounts(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountState) + return target; +} + +int AccountState::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.account.v1.AccountLevelInfo account_level_info = 1; + if (has_account_level_info()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account_level_info()); + } + + // optional .bgs.protocol.account.v1.PrivacyInfo privacy_info = 2; + if (has_privacy_info()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->privacy_info()); + } + + // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 3; + if (has_parental_control_info()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->parental_control_info()); + } + + } + // repeated .bgs.protocol.account.v1.GameLevelInfo game_level_info = 5; + total_size += 1 * this->game_level_info_size(); + for (int i = 0; i < this->game_level_info_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_level_info(i)); + } + + // repeated .bgs.protocol.account.v1.GameStatus game_status = 6; + total_size += 1 * this->game_status_size(); + for (int i = 0; i < this->game_status_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_status(i)); + } + + // repeated .bgs.protocol.account.v1.GameAccountList game_accounts = 7; + total_size += 1 * this->game_accounts_size(); + for (int i = 0; i < this->game_accounts_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_accounts(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 AccountState::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AccountState* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AccountState::MergeFrom(const AccountState& from) { + GOOGLE_CHECK_NE(&from, this); + game_level_info_.MergeFrom(from.game_level_info_); + game_status_.MergeFrom(from.game_status_); + game_accounts_.MergeFrom(from.game_accounts_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_account_level_info()) { + mutable_account_level_info()->::bgs::protocol::account::v1::AccountLevelInfo::MergeFrom(from.account_level_info()); + } + if (from.has_privacy_info()) { + mutable_privacy_info()->::bgs::protocol::account::v1::PrivacyInfo::MergeFrom(from.privacy_info()); + } + if (from.has_parental_control_info()) { + mutable_parental_control_info()->::bgs::protocol::account::v1::ParentalControlInfo::MergeFrom(from.parental_control_info()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AccountState::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AccountState::CopyFrom(const AccountState& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AccountState::IsInitialized() const { + + if (has_account_level_info()) { + if (!this->account_level_info().IsInitialized()) return false; + } + if (!::google::protobuf::internal::AllAreInitialized(this->game_level_info())) return false; + if (!::google::protobuf::internal::AllAreInitialized(this->game_accounts())) return false; + return true; +} + +void AccountState::Swap(AccountState* other) { + if (other != this) { + std::swap(account_level_info_, other->account_level_info_); + std::swap(privacy_info_, other->privacy_info_); + std::swap(parental_control_info_, other->parental_control_info_); + game_level_info_.Swap(&other->game_level_info_); + game_status_.Swap(&other->game_status_); + game_accounts_.Swap(&other->game_accounts_); + 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 AccountState::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AccountState_descriptor_; + metadata.reflection = AccountState_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AccountStateTagged::kAccountStateFieldNumber; +const int AccountStateTagged::kAccountTagsFieldNumber; +#endif // !_MSC_VER + +AccountStateTagged::AccountStateTagged() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountStateTagged) +} + +void AccountStateTagged::InitAsDefaultInstance() { + account_state_ = const_cast< ::bgs::protocol::account::v1::AccountState*>(&::bgs::protocol::account::v1::AccountState::default_instance()); + account_tags_ = const_cast< ::bgs::protocol::account::v1::AccountFieldTags*>(&::bgs::protocol::account::v1::AccountFieldTags::default_instance()); +} + +AccountStateTagged::AccountStateTagged(const AccountStateTagged& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountStateTagged) +} + +void AccountStateTagged::SharedCtor() { + _cached_size_ = 0; + account_state_ = NULL; + account_tags_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AccountStateTagged::~AccountStateTagged() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountStateTagged) + SharedDtor(); +} + +void AccountStateTagged::SharedDtor() { + if (this != default_instance_) { + delete account_state_; + delete account_tags_; + } +} + +void AccountStateTagged::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AccountStateTagged::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AccountStateTagged_descriptor_; +} + +const AccountStateTagged& AccountStateTagged::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +AccountStateTagged* AccountStateTagged::default_instance_ = NULL; + +AccountStateTagged* AccountStateTagged::New() const { + return new AccountStateTagged; +} + +void AccountStateTagged::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_account_state()) { + if (account_state_ != NULL) account_state_->::bgs::protocol::account::v1::AccountState::Clear(); + } + if (has_account_tags()) { + if (account_tags_ != NULL) account_tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AccountStateTagged::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountStateTagged) + 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 .bgs.protocol.account.v1.AccountState account_state = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account_state())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_account_tags; + break; + } + + // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 2; + case 2: { + if (tag == 18) { + parse_account_tags: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account_tags())); + } 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:bgs.protocol.account.v1.AccountStateTagged) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountStateTagged) + return false; +#undef DO_ +} + +void AccountStateTagged::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountStateTagged) + // optional .bgs.protocol.account.v1.AccountState account_state = 1; + if (has_account_state()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->account_state(), output); + } + + // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 2; + if (has_account_tags()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->account_tags(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountStateTagged) +} + +::google::protobuf::uint8* AccountStateTagged::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountStateTagged) + // optional .bgs.protocol.account.v1.AccountState account_state = 1; + if (has_account_state()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->account_state(), target); + } + + // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 2; + if (has_account_tags()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->account_tags(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountStateTagged) + return target; +} + +int AccountStateTagged::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.account.v1.AccountState account_state = 1; + if (has_account_state()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account_state()); + } + + // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 2; + if (has_account_tags()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account_tags()); + } + + } + 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 AccountStateTagged::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AccountStateTagged* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AccountStateTagged::MergeFrom(const AccountStateTagged& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_account_state()) { + mutable_account_state()->::bgs::protocol::account::v1::AccountState::MergeFrom(from.account_state()); + } + if (from.has_account_tags()) { + mutable_account_tags()->::bgs::protocol::account::v1::AccountFieldTags::MergeFrom(from.account_tags()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AccountStateTagged::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AccountStateTagged::CopyFrom(const AccountStateTagged& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AccountStateTagged::IsInitialized() const { + + if (has_account_state()) { + if (!this->account_state().IsInitialized()) return false; + } + return true; +} + +void AccountStateTagged::Swap(AccountStateTagged* other) { + if (other != this) { + std::swap(account_state_, other->account_state_); + std::swap(account_tags_, other->account_tags_); + 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 AccountStateTagged::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AccountStateTagged_descriptor_; + metadata.reflection = AccountStateTagged_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GameAccountState::kGameLevelInfoFieldNumber; +const int GameAccountState::kGameTimeInfoFieldNumber; +const int GameAccountState::kGameStatusFieldNumber; +const int GameAccountState::kRafInfoFieldNumber; +#endif // !_MSC_VER + +GameAccountState::GameAccountState() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountState) +} + +void GameAccountState::InitAsDefaultInstance() { + game_level_info_ = const_cast< ::bgs::protocol::account::v1::GameLevelInfo*>(&::bgs::protocol::account::v1::GameLevelInfo::default_instance()); + game_time_info_ = const_cast< ::bgs::protocol::account::v1::GameTimeInfo*>(&::bgs::protocol::account::v1::GameTimeInfo::default_instance()); + game_status_ = const_cast< ::bgs::protocol::account::v1::GameStatus*>(&::bgs::protocol::account::v1::GameStatus::default_instance()); + raf_info_ = const_cast< ::bgs::protocol::account::v1::RAFInfo*>(&::bgs::protocol::account::v1::RAFInfo::default_instance()); +} + +GameAccountState::GameAccountState(const GameAccountState& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountState) +} + +void GameAccountState::SharedCtor() { + _cached_size_ = 0; + game_level_info_ = NULL; + game_time_info_ = NULL; + game_status_ = NULL; + raf_info_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameAccountState::~GameAccountState() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountState) + SharedDtor(); +} + +void GameAccountState::SharedDtor() { + if (this != default_instance_) { + delete game_level_info_; + delete game_time_info_; + delete game_status_; + delete raf_info_; + } +} + +void GameAccountState::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GameAccountState::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GameAccountState_descriptor_; +} + +const GameAccountState& GameAccountState::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +GameAccountState* GameAccountState::default_instance_ = NULL; + +GameAccountState* GameAccountState::New() const { + return new GameAccountState; +} + +void GameAccountState::Clear() { + if (_has_bits_[0 / 32] & 15) { + if (has_game_level_info()) { + if (game_level_info_ != NULL) game_level_info_->::bgs::protocol::account::v1::GameLevelInfo::Clear(); + } + if (has_game_time_info()) { + if (game_time_info_ != NULL) game_time_info_->::bgs::protocol::account::v1::GameTimeInfo::Clear(); + } + if (has_game_status()) { + if (game_status_ != NULL) game_status_->::bgs::protocol::account::v1::GameStatus::Clear(); + } + if (has_raf_info()) { + if (raf_info_ != NULL) raf_info_->::bgs::protocol::account::v1::RAFInfo::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GameAccountState::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountState) + 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 .bgs.protocol.account.v1.GameLevelInfo game_level_info = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_level_info())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_game_time_info; + break; + } + + // optional .bgs.protocol.account.v1.GameTimeInfo game_time_info = 2; + case 2: { + if (tag == 18) { + parse_game_time_info: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_time_info())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_game_status; + break; + } + + // optional .bgs.protocol.account.v1.GameStatus game_status = 3; + case 3: { + if (tag == 26) { + parse_game_status: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_status())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_raf_info; + break; + } + + // optional .bgs.protocol.account.v1.RAFInfo raf_info = 4; + case 4: { + if (tag == 34) { + parse_raf_info: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_raf_info())); + } 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:bgs.protocol.account.v1.GameAccountState) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountState) + return false; +#undef DO_ +} + +void GameAccountState::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountState) + // optional .bgs.protocol.account.v1.GameLevelInfo game_level_info = 1; + if (has_game_level_info()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->game_level_info(), output); + } + + // optional .bgs.protocol.account.v1.GameTimeInfo game_time_info = 2; + if (has_game_time_info()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->game_time_info(), output); + } + + // optional .bgs.protocol.account.v1.GameStatus game_status = 3; + if (has_game_status()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->game_status(), output); + } + + // optional .bgs.protocol.account.v1.RAFInfo raf_info = 4; + if (has_raf_info()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->raf_info(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountState) +} + +::google::protobuf::uint8* GameAccountState::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountState) + // optional .bgs.protocol.account.v1.GameLevelInfo game_level_info = 1; + if (has_game_level_info()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->game_level_info(), target); + } + + // optional .bgs.protocol.account.v1.GameTimeInfo game_time_info = 2; + if (has_game_time_info()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->game_time_info(), target); + } + + // optional .bgs.protocol.account.v1.GameStatus game_status = 3; + if (has_game_status()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->game_status(), target); + } + + // optional .bgs.protocol.account.v1.RAFInfo raf_info = 4; + if (has_raf_info()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->raf_info(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountState) + return target; +} + +int GameAccountState::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.account.v1.GameLevelInfo game_level_info = 1; + if (has_game_level_info()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_level_info()); + } + + // optional .bgs.protocol.account.v1.GameTimeInfo game_time_info = 2; + if (has_game_time_info()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_time_info()); + } + + // optional .bgs.protocol.account.v1.GameStatus game_status = 3; + if (has_game_status()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_status()); + } + + // optional .bgs.protocol.account.v1.RAFInfo raf_info = 4; + if (has_raf_info()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->raf_info()); + } + + } + 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 GameAccountState::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GameAccountState* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GameAccountState::MergeFrom(const GameAccountState& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_game_level_info()) { + mutable_game_level_info()->::bgs::protocol::account::v1::GameLevelInfo::MergeFrom(from.game_level_info()); + } + if (from.has_game_time_info()) { + mutable_game_time_info()->::bgs::protocol::account::v1::GameTimeInfo::MergeFrom(from.game_time_info()); + } + if (from.has_game_status()) { + mutable_game_status()->::bgs::protocol::account::v1::GameStatus::MergeFrom(from.game_status()); + } + if (from.has_raf_info()) { + mutable_raf_info()->::bgs::protocol::account::v1::RAFInfo::MergeFrom(from.raf_info()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GameAccountState::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GameAccountState::CopyFrom(const GameAccountState& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameAccountState::IsInitialized() const { + + if (has_game_level_info()) { + if (!this->game_level_info().IsInitialized()) return false; + } + return true; +} + +void GameAccountState::Swap(GameAccountState* other) { + if (other != this) { + std::swap(game_level_info_, other->game_level_info_); + std::swap(game_time_info_, other->game_time_info_); + std::swap(game_status_, other->game_status_); + std::swap(raf_info_, other->raf_info_); + 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 GameAccountState::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GameAccountState_descriptor_; + metadata.reflection = GameAccountState_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GameAccountStateTagged::kGameAccountStateFieldNumber; +const int GameAccountStateTagged::kGameAccountTagsFieldNumber; +#endif // !_MSC_VER + +GameAccountStateTagged::GameAccountStateTagged() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountStateTagged) +} + +void GameAccountStateTagged::InitAsDefaultInstance() { + game_account_state_ = const_cast< ::bgs::protocol::account::v1::GameAccountState*>(&::bgs::protocol::account::v1::GameAccountState::default_instance()); + game_account_tags_ = const_cast< ::bgs::protocol::account::v1::GameAccountFieldTags*>(&::bgs::protocol::account::v1::GameAccountFieldTags::default_instance()); +} + +GameAccountStateTagged::GameAccountStateTagged(const GameAccountStateTagged& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountStateTagged) +} + +void GameAccountStateTagged::SharedCtor() { + _cached_size_ = 0; + game_account_state_ = NULL; + game_account_tags_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameAccountStateTagged::~GameAccountStateTagged() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountStateTagged) + SharedDtor(); +} + +void GameAccountStateTagged::SharedDtor() { + if (this != default_instance_) { + delete game_account_state_; + delete game_account_tags_; + } +} + +void GameAccountStateTagged::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GameAccountStateTagged::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GameAccountStateTagged_descriptor_; +} + +const GameAccountStateTagged& GameAccountStateTagged::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +GameAccountStateTagged* GameAccountStateTagged::default_instance_ = NULL; + +GameAccountStateTagged* GameAccountStateTagged::New() const { + return new GameAccountStateTagged; +} + +void GameAccountStateTagged::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_game_account_state()) { + if (game_account_state_ != NULL) game_account_state_->::bgs::protocol::account::v1::GameAccountState::Clear(); + } + if (has_game_account_tags()) { + if (game_account_tags_ != NULL) game_account_tags_->::bgs::protocol::account::v1::GameAccountFieldTags::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GameAccountStateTagged::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountStateTagged) + 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 .bgs.protocol.account.v1.GameAccountState game_account_state = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account_state())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_game_account_tags; + break; + } + + // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 2; + case 2: { + if (tag == 18) { + parse_game_account_tags: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account_tags())); + } 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:bgs.protocol.account.v1.GameAccountStateTagged) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountStateTagged) + return false; +#undef DO_ +} + +void GameAccountStateTagged::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountStateTagged) + // optional .bgs.protocol.account.v1.GameAccountState game_account_state = 1; + if (has_game_account_state()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->game_account_state(), output); + } + + // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 2; + if (has_game_account_tags()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->game_account_tags(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountStateTagged) +} + +::google::protobuf::uint8* GameAccountStateTagged::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountStateTagged) + // optional .bgs.protocol.account.v1.GameAccountState game_account_state = 1; + if (has_game_account_state()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->game_account_state(), target); + } + + // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 2; + if (has_game_account_tags()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->game_account_tags(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountStateTagged) + return target; +} + +int GameAccountStateTagged::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.account.v1.GameAccountState game_account_state = 1; + if (has_game_account_state()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account_state()); + } + + // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 2; + if (has_game_account_tags()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account_tags()); + } + + } + 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 GameAccountStateTagged::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GameAccountStateTagged* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GameAccountStateTagged::MergeFrom(const GameAccountStateTagged& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_game_account_state()) { + mutable_game_account_state()->::bgs::protocol::account::v1::GameAccountState::MergeFrom(from.game_account_state()); + } + if (from.has_game_account_tags()) { + mutable_game_account_tags()->::bgs::protocol::account::v1::GameAccountFieldTags::MergeFrom(from.game_account_tags()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GameAccountStateTagged::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GameAccountStateTagged::CopyFrom(const GameAccountStateTagged& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameAccountStateTagged::IsInitialized() const { + + if (has_game_account_state()) { + if (!this->game_account_state().IsInitialized()) return false; + } + return true; +} + +void GameAccountStateTagged::Swap(GameAccountStateTagged* other) { + if (other != this) { + std::swap(game_account_state_, other->game_account_state_); + std::swap(game_account_tags_, other->game_account_tags_); + 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 GameAccountStateTagged::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GameAccountStateTagged_descriptor_; + metadata.reflection = GameAccountStateTagged_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AuthorizedData::kDataFieldNumber; +const int AuthorizedData::kLicenseFieldNumber; +#endif // !_MSC_VER + +AuthorizedData::AuthorizedData() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AuthorizedData) +} + +void AuthorizedData::InitAsDefaultInstance() { +} + +AuthorizedData::AuthorizedData(const AuthorizedData& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AuthorizedData) +} + +void AuthorizedData::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AuthorizedData::~AuthorizedData() { + // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AuthorizedData) + SharedDtor(); +} + +void AuthorizedData::SharedDtor() { + if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete data_; + } + if (this != default_instance_) { + } +} + +void AuthorizedData::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AuthorizedData::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AuthorizedData_descriptor_; +} + +const AuthorizedData& AuthorizedData::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto(); + return *default_instance_; +} + +AuthorizedData* AuthorizedData::default_instance_ = NULL; + +AuthorizedData* AuthorizedData::New() const { + return new AuthorizedData; +} + +void AuthorizedData::Clear() { + if (has_data()) { + if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_->clear(); + } + } + license_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AuthorizedData::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AuthorizedData) + 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 data = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_data())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->data().data(), this->data().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "data"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_license; + break; + } + + // repeated uint32 license = 2; + case 2: { + if (tag == 16) { + parse_license: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 16, input, this->mutable_license()))); + } else if (tag == 18) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_license()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_license; + 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:bgs.protocol.account.v1.AuthorizedData) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AuthorizedData) + return false; +#undef DO_ +} + +void AuthorizedData::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AuthorizedData) + // optional string data = 1; + if (has_data()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->data().data(), this->data().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "data"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->data(), output); + } + + // repeated uint32 license = 2; + for (int i = 0; i < this->license_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32( + 2, this->license(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AuthorizedData) +} + +::google::protobuf::uint8* AuthorizedData::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AuthorizedData) + // optional string data = 1; + if (has_data()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->data().data(), this->data().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "data"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->data(), target); + } + + // repeated uint32 license = 2; + for (int i = 0; i < this->license_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32ToArray(2, this->license(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AuthorizedData) + return target; +} + +int AuthorizedData::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional string data = 1; + if (has_data()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->data()); + } + + } + // repeated uint32 license = 2; + { + int data_size = 0; + for (int i = 0; i < this->license_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->license(i)); + } + total_size += 1 * this->license_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 AuthorizedData::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AuthorizedData* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AuthorizedData::MergeFrom(const AuthorizedData& from) { + GOOGLE_CHECK_NE(&from, this); + license_.MergeFrom(from.license_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_data()) { + set_data(from.data()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AuthorizedData::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AuthorizedData::CopyFrom(const AuthorizedData& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AuthorizedData::IsInitialized() const { + + return true; +} + +void AuthorizedData::Swap(AuthorizedData* other) { + if (other != this) { + std::swap(data_, other->data_); + license_.Swap(&other->license_); + 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 AuthorizedData::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AuthorizedData_descriptor_; + metadata.reflection = AuthorizedData_reflection_; + return metadata; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace account +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/account_types.pb.h b/src/server/proto/Client/account_types.pb.h new file mode 100644 index 00000000000..f1cc923d30d --- /dev/null +++ b/src/server/proto/Client/account_types.pb.h @@ -0,0 +1,10138 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: account_types.proto + +#ifndef PROTOBUF_account_5ftypes_2eproto__INCLUDED +#define PROTOBUF_account_5ftypes_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include +#include "entity_types.pb.h" +#include "rpc_types.pb.h" +#include "Define.h" // for TRINITY_SHARED_API +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { +namespace account { +namespace v1 { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); +void protobuf_AssignDesc_account_5ftypes_2eproto(); +void protobuf_ShutdownFile_account_5ftypes_2eproto(); + +class AccountId; +class AccountLicense; +class AccountCredential; +class AccountBlob; +class AccountBlobList; +class GameAccountHandle; +class GameAccountLink; +class GameAccountBlob; +class GameAccountBlobList; +class AccountReference; +class Identity; +class ProgramTag; +class RegionTag; +class AccountFieldTags; +class GameAccountFieldTags; +class AccountFieldOptions; +class GameAccountFieldOptions; +class SubscriberReference; +class AccountLevelInfo; +class PrivacyInfo; +class ParentalControlInfo; +class GameLevelInfo; +class GameTimeInfo; +class GameTimeRemainingInfo; +class GameStatus; +class RAFInfo; +class GameSessionInfo; +class GameSessionUpdateInfo; +class GameSessionLocation; +class CAIS; +class GameAccountList; +class AccountState; +class AccountStateTagged; +class GameAccountState; +class GameAccountStateTagged; +class AuthorizedData; + +enum PrivacyInfo_GameInfoPrivacy { + PrivacyInfo_GameInfoPrivacy_PRIVACY_ME = 0, + PrivacyInfo_GameInfoPrivacy_PRIVACY_FRIENDS = 1, + PrivacyInfo_GameInfoPrivacy_PRIVACY_EVERYONE = 2 +}; +TC_SHARED_API bool PrivacyInfo_GameInfoPrivacy_IsValid(int value); +const PrivacyInfo_GameInfoPrivacy PrivacyInfo_GameInfoPrivacy_GameInfoPrivacy_MIN = PrivacyInfo_GameInfoPrivacy_PRIVACY_ME; +const PrivacyInfo_GameInfoPrivacy PrivacyInfo_GameInfoPrivacy_GameInfoPrivacy_MAX = PrivacyInfo_GameInfoPrivacy_PRIVACY_EVERYONE; +const int PrivacyInfo_GameInfoPrivacy_GameInfoPrivacy_ARRAYSIZE = PrivacyInfo_GameInfoPrivacy_GameInfoPrivacy_MAX + 1; + +TC_SHARED_API const ::google::protobuf::EnumDescriptor* PrivacyInfo_GameInfoPrivacy_descriptor(); +inline const ::std::string& PrivacyInfo_GameInfoPrivacy_Name(PrivacyInfo_GameInfoPrivacy value) { + return ::google::protobuf::internal::NameOfEnum( + PrivacyInfo_GameInfoPrivacy_descriptor(), value); +} +inline bool PrivacyInfo_GameInfoPrivacy_Parse( + const ::std::string& name, PrivacyInfo_GameInfoPrivacy* value) { + return ::google::protobuf::internal::ParseNamedEnum( + PrivacyInfo_GameInfoPrivacy_descriptor(), name, value); +} +enum IdentityVerificationStatus { + IDENT_NO_DATA = 0, + IDENT_PENDING = 1, + IDENT_FAILED = 4, + IDENT_SUCCESS = 5, + IDENT_SUCC_MNL = 6, + IDENT_UNKNOWN = 7 +}; +TC_SHARED_API bool IdentityVerificationStatus_IsValid(int value); +const IdentityVerificationStatus IdentityVerificationStatus_MIN = IDENT_NO_DATA; +const IdentityVerificationStatus IdentityVerificationStatus_MAX = IDENT_UNKNOWN; +const int IdentityVerificationStatus_ARRAYSIZE = IdentityVerificationStatus_MAX + 1; + +TC_SHARED_API const ::google::protobuf::EnumDescriptor* IdentityVerificationStatus_descriptor(); +inline const ::std::string& IdentityVerificationStatus_Name(IdentityVerificationStatus value) { + return ::google::protobuf::internal::NameOfEnum( + IdentityVerificationStatus_descriptor(), value); +} +inline bool IdentityVerificationStatus_Parse( + const ::std::string& name, IdentityVerificationStatus* value) { + return ::google::protobuf::internal::ParseNamedEnum( + IdentityVerificationStatus_descriptor(), name, value); +} +// =================================================================== + +class TC_SHARED_API AccountId : public ::google::protobuf::Message { + public: + AccountId(); + virtual ~AccountId(); + + AccountId(const AccountId& from); + + inline AccountId& operator=(const AccountId& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AccountId& default_instance(); + + void Swap(AccountId* other); + + // implements Message ---------------------------------------------- + + AccountId* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AccountId& from); + void MergeFrom(const AccountId& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed32 id = 1; + inline bool has_id() const; + inline void clear_id(); + static const int kIdFieldNumber = 1; + inline ::google::protobuf::uint32 id() const; + inline void set_id(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountId) + private: + inline void set_has_id(); + inline void clear_has_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 id_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static AccountId* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API AccountLicense : public ::google::protobuf::Message { + public: + AccountLicense(); + virtual ~AccountLicense(); + + AccountLicense(const AccountLicense& from); + + inline AccountLicense& operator=(const AccountLicense& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AccountLicense& default_instance(); + + void Swap(AccountLicense* other); + + // implements Message ---------------------------------------------- + + AccountLicense* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AccountLicense& from); + void MergeFrom(const AccountLicense& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required uint32 id = 1; + inline bool has_id() const; + inline void clear_id(); + static const int kIdFieldNumber = 1; + inline ::google::protobuf::uint32 id() const; + inline void set_id(::google::protobuf::uint32 value); + + // optional uint64 expires = 2; + inline bool has_expires() const; + inline void clear_expires(); + static const int kExpiresFieldNumber = 2; + inline ::google::protobuf::uint64 expires() const; + inline void set_expires(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountLicense) + private: + inline void set_has_id(); + inline void clear_has_id(); + inline void set_has_expires(); + inline void clear_has_expires(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint64 expires_; + ::google::protobuf::uint32 id_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static AccountLicense* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API AccountCredential : public ::google::protobuf::Message { + public: + AccountCredential(); + virtual ~AccountCredential(); + + AccountCredential(const AccountCredential& from); + + inline AccountCredential& operator=(const AccountCredential& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AccountCredential& default_instance(); + + void Swap(AccountCredential* other); + + // implements Message ---------------------------------------------- + + AccountCredential* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AccountCredential& from); + void MergeFrom(const AccountCredential& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required uint32 id = 1; + inline bool has_id() const; + inline void clear_id(); + static const int kIdFieldNumber = 1; + inline ::google::protobuf::uint32 id() const; + inline void set_id(::google::protobuf::uint32 value); + + // optional bytes data = 2; + inline bool has_data() const; + inline void clear_data(); + static const int kDataFieldNumber = 2; + inline const ::std::string& data() const; + inline void set_data(const ::std::string& value); + inline void set_data(const char* value); + inline void set_data(const void* value, size_t size); + inline ::std::string* mutable_data(); + inline ::std::string* release_data(); + inline void set_allocated_data(::std::string* data); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountCredential) + private: + inline void set_has_id(); + inline void clear_has_id(); + inline void set_has_data(); + inline void clear_has_data(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* data_; + ::google::protobuf::uint32 id_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static AccountCredential* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API AccountBlob : public ::google::protobuf::Message { + public: + AccountBlob(); + virtual ~AccountBlob(); + + AccountBlob(const AccountBlob& from); + + inline AccountBlob& operator=(const AccountBlob& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AccountBlob& default_instance(); + + void Swap(AccountBlob* other); + + // implements Message ---------------------------------------------- + + AccountBlob* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AccountBlob& from); + void MergeFrom(const AccountBlob& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed32 id = 2; + inline bool has_id() const; + inline void clear_id(); + static const int kIdFieldNumber = 2; + inline ::google::protobuf::uint32 id() const; + inline void set_id(::google::protobuf::uint32 value); + + // required uint32 region = 3; + inline bool has_region() const; + inline void clear_region(); + static const int kRegionFieldNumber = 3; + inline ::google::protobuf::uint32 region() const; + inline void set_region(::google::protobuf::uint32 value); + + // repeated string email = 4; + inline int email_size() const; + inline void clear_email(); + static const int kEmailFieldNumber = 4; + inline const ::std::string& email(int index) const; + inline ::std::string* mutable_email(int index); + inline void set_email(int index, const ::std::string& value); + inline void set_email(int index, const char* value); + inline void set_email(int index, const char* value, size_t size); + inline ::std::string* add_email(); + inline void add_email(const ::std::string& value); + inline void add_email(const char* value); + inline void add_email(const char* value, size_t size); + inline const ::google::protobuf::RepeatedPtrField< ::std::string>& email() const; + inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_email(); + + // required uint64 flags = 5; + inline bool has_flags() const; + inline void clear_flags(); + static const int kFlagsFieldNumber = 5; + inline ::google::protobuf::uint64 flags() const; + inline void set_flags(::google::protobuf::uint64 value); + + // optional uint64 secure_release = 6; + inline bool has_secure_release() const; + inline void clear_secure_release(); + static const int kSecureReleaseFieldNumber = 6; + inline ::google::protobuf::uint64 secure_release() const; + inline void set_secure_release(::google::protobuf::uint64 value); + + // optional uint64 whitelist_start = 7; + inline bool has_whitelist_start() const; + inline void clear_whitelist_start(); + static const int kWhitelistStartFieldNumber = 7; + inline ::google::protobuf::uint64 whitelist_start() const; + inline void set_whitelist_start(::google::protobuf::uint64 value); + + // optional uint64 whitelist_end = 8; + inline bool has_whitelist_end() const; + inline void clear_whitelist_end(); + static const int kWhitelistEndFieldNumber = 8; + inline ::google::protobuf::uint64 whitelist_end() const; + inline void set_whitelist_end(::google::protobuf::uint64 value); + + // required string full_name = 10; + inline bool has_full_name() const; + inline void clear_full_name(); + static const int kFullNameFieldNumber = 10; + inline const ::std::string& full_name() const; + inline void set_full_name(const ::std::string& value); + inline void set_full_name(const char* value); + inline void set_full_name(const char* value, size_t size); + inline ::std::string* mutable_full_name(); + inline ::std::string* release_full_name(); + inline void set_allocated_full_name(::std::string* full_name); + + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20; + inline int licenses_size() const; + inline void clear_licenses(); + static const int kLicensesFieldNumber = 20; + inline const ::bgs::protocol::account::v1::AccountLicense& licenses(int index) const; + inline ::bgs::protocol::account::v1::AccountLicense* mutable_licenses(int index); + inline ::bgs::protocol::account::v1::AccountLicense* add_licenses(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >& + licenses() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >* + mutable_licenses(); + + // repeated .bgs.protocol.account.v1.AccountCredential credentials = 21; + inline int credentials_size() const; + inline void clear_credentials(); + static const int kCredentialsFieldNumber = 21; + inline const ::bgs::protocol::account::v1::AccountCredential& credentials(int index) const; + inline ::bgs::protocol::account::v1::AccountCredential* mutable_credentials(int index); + inline ::bgs::protocol::account::v1::AccountCredential* add_credentials(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >& + credentials() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >* + mutable_credentials(); + + // repeated .bgs.protocol.account.v1.GameAccountLink account_links = 22; + inline int account_links_size() const; + inline void clear_account_links(); + static const int kAccountLinksFieldNumber = 22; + inline const ::bgs::protocol::account::v1::GameAccountLink& account_links(int index) const; + inline ::bgs::protocol::account::v1::GameAccountLink* mutable_account_links(int index); + inline ::bgs::protocol::account::v1::GameAccountLink* add_account_links(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink >& + account_links() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink >* + mutable_account_links(); + + // optional string battle_tag = 23; + inline bool has_battle_tag() const; + inline void clear_battle_tag(); + static const int kBattleTagFieldNumber = 23; + inline const ::std::string& battle_tag() const; + inline void set_battle_tag(const ::std::string& value); + inline void set_battle_tag(const char* value); + inline void set_battle_tag(const char* value, size_t size); + inline ::std::string* mutable_battle_tag(); + inline ::std::string* release_battle_tag(); + inline void set_allocated_battle_tag(::std::string* battle_tag); + + // optional fixed32 default_currency = 25; + inline bool has_default_currency() const; + inline void clear_default_currency(); + static const int kDefaultCurrencyFieldNumber = 25; + inline ::google::protobuf::uint32 default_currency() const; + inline void set_default_currency(::google::protobuf::uint32 value); + + // optional uint32 legal_region = 26; + inline bool has_legal_region() const; + inline void clear_legal_region(); + static const int kLegalRegionFieldNumber = 26; + inline ::google::protobuf::uint32 legal_region() const; + inline void set_legal_region(::google::protobuf::uint32 value); + + // optional fixed32 legal_locale = 27; + inline bool has_legal_locale() const; + inline void clear_legal_locale(); + static const int kLegalLocaleFieldNumber = 27; + inline ::google::protobuf::uint32 legal_locale() const; + inline void set_legal_locale(::google::protobuf::uint32 value); + + // required uint64 cache_expiration = 30; + inline bool has_cache_expiration() const; + inline void clear_cache_expiration(); + static const int kCacheExpirationFieldNumber = 30; + inline ::google::protobuf::uint64 cache_expiration() const; + inline void set_cache_expiration(::google::protobuf::uint64 value); + + // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 31; + inline bool has_parental_control_info() const; + inline void clear_parental_control_info(); + static const int kParentalControlInfoFieldNumber = 31; + inline const ::bgs::protocol::account::v1::ParentalControlInfo& parental_control_info() const; + inline ::bgs::protocol::account::v1::ParentalControlInfo* mutable_parental_control_info(); + inline ::bgs::protocol::account::v1::ParentalControlInfo* release_parental_control_info(); + inline void set_allocated_parental_control_info(::bgs::protocol::account::v1::ParentalControlInfo* parental_control_info); + + // optional string country = 32; + inline bool has_country() const; + inline void clear_country(); + static const int kCountryFieldNumber = 32; + inline const ::std::string& country() const; + inline void set_country(const ::std::string& value); + inline void set_country(const char* value); + inline void set_country(const char* value, size_t size); + inline ::std::string* mutable_country(); + inline ::std::string* release_country(); + inline void set_allocated_country(::std::string* country); + + // optional uint32 preferred_region = 33; + inline bool has_preferred_region() const; + inline void clear_preferred_region(); + static const int kPreferredRegionFieldNumber = 33; + inline ::google::protobuf::uint32 preferred_region() const; + inline void set_preferred_region(::google::protobuf::uint32 value); + + // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 34; + inline bool has_identity_check_status() const; + inline void clear_identity_check_status(); + static const int kIdentityCheckStatusFieldNumber = 34; + inline ::bgs::protocol::account::v1::IdentityVerificationStatus identity_check_status() const; + inline void set_identity_check_status(::bgs::protocol::account::v1::IdentityVerificationStatus value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountBlob) + private: + inline void set_has_id(); + inline void clear_has_id(); + inline void set_has_region(); + inline void clear_has_region(); + inline void set_has_flags(); + inline void clear_has_flags(); + inline void set_has_secure_release(); + inline void clear_has_secure_release(); + inline void set_has_whitelist_start(); + inline void clear_has_whitelist_start(); + inline void set_has_whitelist_end(); + inline void clear_has_whitelist_end(); + inline void set_has_full_name(); + inline void clear_has_full_name(); + inline void set_has_battle_tag(); + inline void clear_has_battle_tag(); + inline void set_has_default_currency(); + inline void clear_has_default_currency(); + inline void set_has_legal_region(); + inline void clear_has_legal_region(); + inline void set_has_legal_locale(); + inline void clear_has_legal_locale(); + inline void set_has_cache_expiration(); + inline void clear_has_cache_expiration(); + inline void set_has_parental_control_info(); + inline void clear_has_parental_control_info(); + inline void set_has_country(); + inline void clear_has_country(); + inline void set_has_preferred_region(); + inline void clear_has_preferred_region(); + inline void set_has_identity_check_status(); + inline void clear_has_identity_check_status(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 id_; + ::google::protobuf::uint32 region_; + ::google::protobuf::RepeatedPtrField< ::std::string> email_; + ::google::protobuf::uint64 flags_; + ::google::protobuf::uint64 secure_release_; + ::google::protobuf::uint64 whitelist_start_; + ::google::protobuf::uint64 whitelist_end_; + ::std::string* full_name_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense > licenses_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential > credentials_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink > account_links_; + ::std::string* battle_tag_; + ::google::protobuf::uint32 default_currency_; + ::google::protobuf::uint32 legal_region_; + ::google::protobuf::uint64 cache_expiration_; + ::bgs::protocol::account::v1::ParentalControlInfo* parental_control_info_; + ::google::protobuf::uint32 legal_locale_; + ::google::protobuf::uint32 preferred_region_; + ::std::string* country_; + int identity_check_status_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static AccountBlob* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API AccountBlobList : public ::google::protobuf::Message { + public: + AccountBlobList(); + virtual ~AccountBlobList(); + + AccountBlobList(const AccountBlobList& from); + + inline AccountBlobList& operator=(const AccountBlobList& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AccountBlobList& default_instance(); + + void Swap(AccountBlobList* other); + + // implements Message ---------------------------------------------- + + AccountBlobList* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AccountBlobList& from); + void MergeFrom(const AccountBlobList& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.account.v1.AccountBlob blob = 1; + inline int blob_size() const; + inline void clear_blob(); + static const int kBlobFieldNumber = 1; + inline const ::bgs::protocol::account::v1::AccountBlob& blob(int index) const; + inline ::bgs::protocol::account::v1::AccountBlob* mutable_blob(int index); + inline ::bgs::protocol::account::v1::AccountBlob* add_blob(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountBlob >& + blob() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountBlob >* + mutable_blob(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountBlobList) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountBlob > blob_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static AccountBlobList* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GameAccountHandle : public ::google::protobuf::Message { + public: + GameAccountHandle(); + virtual ~GameAccountHandle(); + + GameAccountHandle(const GameAccountHandle& from); + + inline GameAccountHandle& operator=(const GameAccountHandle& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GameAccountHandle& default_instance(); + + void Swap(GameAccountHandle* other); + + // implements Message ---------------------------------------------- + + GameAccountHandle* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GameAccountHandle& from); + void MergeFrom(const GameAccountHandle& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed32 id = 1; + inline bool has_id() const; + inline void clear_id(); + static const int kIdFieldNumber = 1; + inline ::google::protobuf::uint32 id() const; + inline void set_id(::google::protobuf::uint32 value); + + // required fixed32 program = 2; + inline bool has_program() const; + inline void clear_program(); + static const int kProgramFieldNumber = 2; + inline ::google::protobuf::uint32 program() const; + inline void set_program(::google::protobuf::uint32 value); + + // required uint32 region = 3; + inline bool has_region() const; + inline void clear_region(); + static const int kRegionFieldNumber = 3; + inline ::google::protobuf::uint32 region() const; + inline void set_region(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountHandle) + private: + inline void set_has_id(); + inline void clear_has_id(); + inline void set_has_program(); + inline void clear_has_program(); + inline void set_has_region(); + inline void clear_has_region(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 id_; + ::google::protobuf::uint32 program_; + ::google::protobuf::uint32 region_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static GameAccountHandle* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GameAccountLink : public ::google::protobuf::Message { + public: + GameAccountLink(); + virtual ~GameAccountLink(); + + GameAccountLink(const GameAccountLink& from); + + inline GameAccountLink& operator=(const GameAccountLink& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GameAccountLink& default_instance(); + + void Swap(GameAccountLink* other); + + // implements Message ---------------------------------------------- + + GameAccountLink* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GameAccountLink& from); + void MergeFrom(const GameAccountLink& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1; + inline bool has_game_account() const; + inline void clear_game_account(); + static const int kGameAccountFieldNumber = 1; + inline const ::bgs::protocol::account::v1::GameAccountHandle& game_account() const; + inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_game_account(); + inline ::bgs::protocol::account::v1::GameAccountHandle* release_game_account(); + inline void set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account); + + // required string name = 2; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 2; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + inline ::std::string* release_name(); + inline void set_allocated_name(::std::string* name); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountLink) + private: + inline void set_has_game_account(); + inline void clear_has_game_account(); + inline void set_has_name(); + inline void clear_has_name(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::account::v1::GameAccountHandle* game_account_; + ::std::string* name_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static GameAccountLink* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GameAccountBlob : public ::google::protobuf::Message { + public: + GameAccountBlob(); + virtual ~GameAccountBlob(); + + GameAccountBlob(const GameAccountBlob& from); + + inline GameAccountBlob& operator=(const GameAccountBlob& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GameAccountBlob& default_instance(); + + void Swap(GameAccountBlob* other); + + // implements Message ---------------------------------------------- + + GameAccountBlob* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GameAccountBlob& from); + void MergeFrom(const GameAccountBlob& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1; + inline bool has_game_account() const; + inline void clear_game_account(); + static const int kGameAccountFieldNumber = 1; + inline const ::bgs::protocol::account::v1::GameAccountHandle& game_account() const; + inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_game_account(); + inline ::bgs::protocol::account::v1::GameAccountHandle* release_game_account(); + inline void set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account); + + // optional string name = 2 [default = ""]; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 2; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + inline ::std::string* release_name(); + inline void set_allocated_name(::std::string* name); + + // optional uint32 realm_permissions = 3 [default = 0]; + inline bool has_realm_permissions() const; + inline void clear_realm_permissions(); + static const int kRealmPermissionsFieldNumber = 3; + inline ::google::protobuf::uint32 realm_permissions() const; + inline void set_realm_permissions(::google::protobuf::uint32 value); + + // required uint32 status = 4; + inline bool has_status() const; + inline void clear_status(); + static const int kStatusFieldNumber = 4; + inline ::google::protobuf::uint32 status() const; + inline void set_status(::google::protobuf::uint32 value); + + // optional uint64 flags = 5 [default = 0]; + inline bool has_flags() const; + inline void clear_flags(); + static const int kFlagsFieldNumber = 5; + inline ::google::protobuf::uint64 flags() const; + inline void set_flags(::google::protobuf::uint64 value); + + // optional uint32 billing_flags = 6 [default = 0]; + inline bool has_billing_flags() const; + inline void clear_billing_flags(); + static const int kBillingFlagsFieldNumber = 6; + inline ::google::protobuf::uint32 billing_flags() const; + inline void set_billing_flags(::google::protobuf::uint32 value); + + // required uint64 cache_expiration = 7; + inline bool has_cache_expiration() const; + inline void clear_cache_expiration(); + static const int kCacheExpirationFieldNumber = 7; + inline ::google::protobuf::uint64 cache_expiration() const; + inline void set_cache_expiration(::google::protobuf::uint64 value); + + // optional uint64 subscription_expiration = 10; + inline bool has_subscription_expiration() const; + inline void clear_subscription_expiration(); + static const int kSubscriptionExpirationFieldNumber = 10; + inline ::google::protobuf::uint64 subscription_expiration() const; + inline void set_subscription_expiration(::google::protobuf::uint64 value); + + // optional uint32 units_remaining = 11; + inline bool has_units_remaining() const; + inline void clear_units_remaining(); + static const int kUnitsRemainingFieldNumber = 11; + inline ::google::protobuf::uint32 units_remaining() const; + inline void set_units_remaining(::google::protobuf::uint32 value); + + // optional uint64 status_expiration = 12; + inline bool has_status_expiration() const; + inline void clear_status_expiration(); + static const int kStatusExpirationFieldNumber = 12; + inline ::google::protobuf::uint64 status_expiration() const; + inline void set_status_expiration(::google::protobuf::uint64 value); + + // optional uint32 box_level = 13; + inline bool has_box_level() const; + inline void clear_box_level(); + static const int kBoxLevelFieldNumber = 13; + inline ::google::protobuf::uint32 box_level() const; + inline void set_box_level(::google::protobuf::uint32 value); + + // optional uint64 box_level_expiration = 14; + inline bool has_box_level_expiration() const; + inline void clear_box_level_expiration(); + static const int kBoxLevelExpirationFieldNumber = 14; + inline ::google::protobuf::uint64 box_level_expiration() const; + inline void set_box_level_expiration(::google::protobuf::uint64 value); + + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20; + inline int licenses_size() const; + inline void clear_licenses(); + static const int kLicensesFieldNumber = 20; + inline const ::bgs::protocol::account::v1::AccountLicense& licenses(int index) const; + inline ::bgs::protocol::account::v1::AccountLicense* mutable_licenses(int index); + inline ::bgs::protocol::account::v1::AccountLicense* add_licenses(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >& + licenses() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >* + mutable_licenses(); + + // optional fixed32 raf_account = 21; + inline bool has_raf_account() const; + inline void clear_raf_account(); + static const int kRafAccountFieldNumber = 21; + inline ::google::protobuf::uint32 raf_account() const; + inline void set_raf_account(::google::protobuf::uint32 value); + + // optional bytes raf_info = 22; + inline bool has_raf_info() const; + inline void clear_raf_info(); + static const int kRafInfoFieldNumber = 22; + inline const ::std::string& raf_info() const; + inline void set_raf_info(const ::std::string& value); + inline void set_raf_info(const char* value); + inline void set_raf_info(const void* value, size_t size); + inline ::std::string* mutable_raf_info(); + inline ::std::string* release_raf_info(); + inline void set_allocated_raf_info(::std::string* raf_info); + + // optional uint64 raf_expiration = 23; + inline bool has_raf_expiration() const; + inline void clear_raf_expiration(); + static const int kRafExpirationFieldNumber = 23; + inline ::google::protobuf::uint64 raf_expiration() const; + inline void set_raf_expiration(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountBlob) + private: + inline void set_has_game_account(); + inline void clear_has_game_account(); + inline void set_has_name(); + inline void clear_has_name(); + inline void set_has_realm_permissions(); + inline void clear_has_realm_permissions(); + inline void set_has_status(); + inline void clear_has_status(); + inline void set_has_flags(); + inline void clear_has_flags(); + inline void set_has_billing_flags(); + inline void clear_has_billing_flags(); + inline void set_has_cache_expiration(); + inline void clear_has_cache_expiration(); + inline void set_has_subscription_expiration(); + inline void clear_has_subscription_expiration(); + inline void set_has_units_remaining(); + inline void clear_has_units_remaining(); + inline void set_has_status_expiration(); + inline void clear_has_status_expiration(); + inline void set_has_box_level(); + inline void clear_has_box_level(); + inline void set_has_box_level_expiration(); + inline void clear_has_box_level_expiration(); + inline void set_has_raf_account(); + inline void clear_has_raf_account(); + inline void set_has_raf_info(); + inline void clear_has_raf_info(); + inline void set_has_raf_expiration(); + inline void clear_has_raf_expiration(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::account::v1::GameAccountHandle* game_account_; + ::std::string* name_; + ::google::protobuf::uint32 realm_permissions_; + ::google::protobuf::uint32 status_; + ::google::protobuf::uint64 flags_; + ::google::protobuf::uint64 cache_expiration_; + ::google::protobuf::uint32 billing_flags_; + ::google::protobuf::uint32 units_remaining_; + ::google::protobuf::uint64 subscription_expiration_; + ::google::protobuf::uint64 status_expiration_; + ::google::protobuf::uint64 box_level_expiration_; + ::google::protobuf::uint32 box_level_; + ::google::protobuf::uint32 raf_account_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense > licenses_; + ::std::string* raf_info_; + ::google::protobuf::uint64 raf_expiration_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static GameAccountBlob* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GameAccountBlobList : public ::google::protobuf::Message { + public: + GameAccountBlobList(); + virtual ~GameAccountBlobList(); + + GameAccountBlobList(const GameAccountBlobList& from); + + inline GameAccountBlobList& operator=(const GameAccountBlobList& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GameAccountBlobList& default_instance(); + + void Swap(GameAccountBlobList* other); + + // implements Message ---------------------------------------------- + + GameAccountBlobList* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GameAccountBlobList& from); + void MergeFrom(const GameAccountBlobList& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.account.v1.GameAccountBlob blob = 1; + inline int blob_size() const; + inline void clear_blob(); + static const int kBlobFieldNumber = 1; + inline const ::bgs::protocol::account::v1::GameAccountBlob& blob(int index) const; + inline ::bgs::protocol::account::v1::GameAccountBlob* mutable_blob(int index); + inline ::bgs::protocol::account::v1::GameAccountBlob* add_blob(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountBlob >& + blob() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountBlob >* + mutable_blob(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountBlobList) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountBlob > blob_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static GameAccountBlobList* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API AccountReference : public ::google::protobuf::Message { + public: + AccountReference(); + virtual ~AccountReference(); + + AccountReference(const AccountReference& from); + + inline AccountReference& operator=(const AccountReference& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AccountReference& default_instance(); + + void Swap(AccountReference* other); + + // implements Message ---------------------------------------------- + + AccountReference* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AccountReference& from); + void MergeFrom(const AccountReference& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional fixed32 id = 1; + inline bool has_id() const; + inline void clear_id(); + static const int kIdFieldNumber = 1; + inline ::google::protobuf::uint32 id() const; + inline void set_id(::google::protobuf::uint32 value); + + // optional string email = 2; + inline bool has_email() const; + inline void clear_email(); + static const int kEmailFieldNumber = 2; + inline const ::std::string& email() const; + inline void set_email(const ::std::string& value); + inline void set_email(const char* value); + inline void set_email(const char* value, size_t size); + inline ::std::string* mutable_email(); + inline ::std::string* release_email(); + inline void set_allocated_email(::std::string* email); + + // optional .bgs.protocol.account.v1.GameAccountHandle handle = 3; + inline bool has_handle() const; + inline void clear_handle(); + static const int kHandleFieldNumber = 3; + inline const ::bgs::protocol::account::v1::GameAccountHandle& handle() const; + inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_handle(); + inline ::bgs::protocol::account::v1::GameAccountHandle* release_handle(); + inline void set_allocated_handle(::bgs::protocol::account::v1::GameAccountHandle* handle); + + // optional string battle_tag = 4; + inline bool has_battle_tag() const; + inline void clear_battle_tag(); + static const int kBattleTagFieldNumber = 4; + inline const ::std::string& battle_tag() const; + inline void set_battle_tag(const ::std::string& value); + inline void set_battle_tag(const char* value); + inline void set_battle_tag(const char* value, size_t size); + inline ::std::string* mutable_battle_tag(); + inline ::std::string* release_battle_tag(); + inline void set_allocated_battle_tag(::std::string* battle_tag); + + // optional uint32 region = 10 [default = 0]; + inline bool has_region() const; + inline void clear_region(); + static const int kRegionFieldNumber = 10; + inline ::google::protobuf::uint32 region() const; + inline void set_region(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountReference) + private: + inline void set_has_id(); + inline void clear_has_id(); + inline void set_has_email(); + inline void clear_has_email(); + inline void set_has_handle(); + inline void clear_has_handle(); + inline void set_has_battle_tag(); + inline void clear_has_battle_tag(); + inline void set_has_region(); + inline void clear_has_region(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* email_; + ::bgs::protocol::account::v1::GameAccountHandle* handle_; + ::google::protobuf::uint32 id_; + ::google::protobuf::uint32 region_; + ::std::string* battle_tag_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static AccountReference* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API Identity : public ::google::protobuf::Message { + public: + Identity(); + virtual ~Identity(); + + Identity(const Identity& from); + + inline Identity& operator=(const Identity& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Identity& default_instance(); + + void Swap(Identity* other); + + // implements Message ---------------------------------------------- + + Identity* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Identity& from); + void MergeFrom(const Identity& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.account.v1.AccountId account = 1; + inline bool has_account() const; + inline void clear_account(); + static const int kAccountFieldNumber = 1; + inline const ::bgs::protocol::account::v1::AccountId& account() const; + inline ::bgs::protocol::account::v1::AccountId* mutable_account(); + inline ::bgs::protocol::account::v1::AccountId* release_account(); + inline void set_allocated_account(::bgs::protocol::account::v1::AccountId* account); + + // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 2; + inline bool has_game_account() const; + inline void clear_game_account(); + static const int kGameAccountFieldNumber = 2; + inline const ::bgs::protocol::account::v1::GameAccountHandle& game_account() const; + inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_game_account(); + inline ::bgs::protocol::account::v1::GameAccountHandle* release_game_account(); + inline void set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account); + + // optional .bgs.protocol.ProcessId process = 3; + inline bool has_process() const; + inline void clear_process(); + static const int kProcessFieldNumber = 3; + inline const ::bgs::protocol::ProcessId& process() const; + inline ::bgs::protocol::ProcessId* mutable_process(); + inline ::bgs::protocol::ProcessId* release_process(); + inline void set_allocated_process(::bgs::protocol::ProcessId* process); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.Identity) + private: + inline void set_has_account(); + inline void clear_has_account(); + inline void set_has_game_account(); + inline void clear_has_game_account(); + inline void set_has_process(); + inline void clear_has_process(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::account::v1::AccountId* account_; + ::bgs::protocol::account::v1::GameAccountHandle* game_account_; + ::bgs::protocol::ProcessId* process_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static Identity* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ProgramTag : public ::google::protobuf::Message { + public: + ProgramTag(); + virtual ~ProgramTag(); + + ProgramTag(const ProgramTag& from); + + inline ProgramTag& operator=(const ProgramTag& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ProgramTag& default_instance(); + + void Swap(ProgramTag* other); + + // implements Message ---------------------------------------------- + + ProgramTag* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ProgramTag& from); + void MergeFrom(const ProgramTag& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional fixed32 program = 1; + inline bool has_program() const; + inline void clear_program(); + static const int kProgramFieldNumber = 1; + inline ::google::protobuf::uint32 program() const; + inline void set_program(::google::protobuf::uint32 value); + + // optional fixed32 tag = 2; + inline bool has_tag() const; + inline void clear_tag(); + static const int kTagFieldNumber = 2; + inline ::google::protobuf::uint32 tag() const; + inline void set_tag(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.ProgramTag) + private: + inline void set_has_program(); + inline void clear_has_program(); + inline void set_has_tag(); + inline void clear_has_tag(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 program_; + ::google::protobuf::uint32 tag_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static ProgramTag* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API RegionTag : public ::google::protobuf::Message { + public: + RegionTag(); + virtual ~RegionTag(); + + RegionTag(const RegionTag& from); + + inline RegionTag& operator=(const RegionTag& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const RegionTag& default_instance(); + + void Swap(RegionTag* other); + + // implements Message ---------------------------------------------- + + RegionTag* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const RegionTag& from); + void MergeFrom(const RegionTag& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional fixed32 region = 1; + inline bool has_region() const; + inline void clear_region(); + static const int kRegionFieldNumber = 1; + inline ::google::protobuf::uint32 region() const; + inline void set_region(::google::protobuf::uint32 value); + + // optional fixed32 tag = 2; + inline bool has_tag() const; + inline void clear_tag(); + static const int kTagFieldNumber = 2; + inline ::google::protobuf::uint32 tag() const; + inline void set_tag(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.RegionTag) + private: + inline void set_has_region(); + inline void clear_has_region(); + inline void set_has_tag(); + inline void clear_has_tag(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 region_; + ::google::protobuf::uint32 tag_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static RegionTag* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API AccountFieldTags : public ::google::protobuf::Message { + public: + AccountFieldTags(); + virtual ~AccountFieldTags(); + + AccountFieldTags(const AccountFieldTags& from); + + inline AccountFieldTags& operator=(const AccountFieldTags& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AccountFieldTags& default_instance(); + + void Swap(AccountFieldTags* other); + + // implements Message ---------------------------------------------- + + AccountFieldTags* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AccountFieldTags& from); + void MergeFrom(const AccountFieldTags& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional fixed32 account_level_info_tag = 2; + inline bool has_account_level_info_tag() const; + inline void clear_account_level_info_tag(); + static const int kAccountLevelInfoTagFieldNumber = 2; + inline ::google::protobuf::uint32 account_level_info_tag() const; + inline void set_account_level_info_tag(::google::protobuf::uint32 value); + + // optional fixed32 privacy_info_tag = 3; + inline bool has_privacy_info_tag() const; + inline void clear_privacy_info_tag(); + static const int kPrivacyInfoTagFieldNumber = 3; + inline ::google::protobuf::uint32 privacy_info_tag() const; + inline void set_privacy_info_tag(::google::protobuf::uint32 value); + + // optional fixed32 parental_control_info_tag = 4; + inline bool has_parental_control_info_tag() const; + inline void clear_parental_control_info_tag(); + static const int kParentalControlInfoTagFieldNumber = 4; + inline ::google::protobuf::uint32 parental_control_info_tag() const; + inline void set_parental_control_info_tag(::google::protobuf::uint32 value); + + // repeated .bgs.protocol.account.v1.ProgramTag game_level_info_tags = 7; + inline int game_level_info_tags_size() const; + inline void clear_game_level_info_tags(); + static const int kGameLevelInfoTagsFieldNumber = 7; + inline const ::bgs::protocol::account::v1::ProgramTag& game_level_info_tags(int index) const; + inline ::bgs::protocol::account::v1::ProgramTag* mutable_game_level_info_tags(int index); + inline ::bgs::protocol::account::v1::ProgramTag* add_game_level_info_tags(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::ProgramTag >& + game_level_info_tags() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::ProgramTag >* + mutable_game_level_info_tags(); + + // repeated .bgs.protocol.account.v1.ProgramTag game_status_tags = 9; + inline int game_status_tags_size() const; + inline void clear_game_status_tags(); + static const int kGameStatusTagsFieldNumber = 9; + inline const ::bgs::protocol::account::v1::ProgramTag& game_status_tags(int index) const; + inline ::bgs::protocol::account::v1::ProgramTag* mutable_game_status_tags(int index); + inline ::bgs::protocol::account::v1::ProgramTag* add_game_status_tags(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::ProgramTag >& + game_status_tags() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::ProgramTag >* + mutable_game_status_tags(); + + // repeated .bgs.protocol.account.v1.RegionTag game_account_tags = 11; + inline int game_account_tags_size() const; + inline void clear_game_account_tags(); + static const int kGameAccountTagsFieldNumber = 11; + inline const ::bgs::protocol::account::v1::RegionTag& game_account_tags(int index) const; + inline ::bgs::protocol::account::v1::RegionTag* mutable_game_account_tags(int index); + inline ::bgs::protocol::account::v1::RegionTag* add_game_account_tags(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::RegionTag >& + game_account_tags() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::RegionTag >* + mutable_game_account_tags(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountFieldTags) + private: + inline void set_has_account_level_info_tag(); + inline void clear_has_account_level_info_tag(); + inline void set_has_privacy_info_tag(); + inline void clear_has_privacy_info_tag(); + inline void set_has_parental_control_info_tag(); + inline void clear_has_parental_control_info_tag(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 account_level_info_tag_; + ::google::protobuf::uint32 privacy_info_tag_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::ProgramTag > game_level_info_tags_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::ProgramTag > game_status_tags_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::RegionTag > game_account_tags_; + ::google::protobuf::uint32 parental_control_info_tag_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static AccountFieldTags* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GameAccountFieldTags : public ::google::protobuf::Message { + public: + GameAccountFieldTags(); + virtual ~GameAccountFieldTags(); + + GameAccountFieldTags(const GameAccountFieldTags& from); + + inline GameAccountFieldTags& operator=(const GameAccountFieldTags& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GameAccountFieldTags& default_instance(); + + void Swap(GameAccountFieldTags* other); + + // implements Message ---------------------------------------------- + + GameAccountFieldTags* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GameAccountFieldTags& from); + void MergeFrom(const GameAccountFieldTags& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional fixed32 game_level_info_tag = 2; + inline bool has_game_level_info_tag() const; + inline void clear_game_level_info_tag(); + static const int kGameLevelInfoTagFieldNumber = 2; + inline ::google::protobuf::uint32 game_level_info_tag() const; + inline void set_game_level_info_tag(::google::protobuf::uint32 value); + + // optional fixed32 game_time_info_tag = 3; + inline bool has_game_time_info_tag() const; + inline void clear_game_time_info_tag(); + static const int kGameTimeInfoTagFieldNumber = 3; + inline ::google::protobuf::uint32 game_time_info_tag() const; + inline void set_game_time_info_tag(::google::protobuf::uint32 value); + + // optional fixed32 game_status_tag = 4; + inline bool has_game_status_tag() const; + inline void clear_game_status_tag(); + static const int kGameStatusTagFieldNumber = 4; + inline ::google::protobuf::uint32 game_status_tag() const; + inline void set_game_status_tag(::google::protobuf::uint32 value); + + // optional fixed32 raf_info_tag = 5; + inline bool has_raf_info_tag() const; + inline void clear_raf_info_tag(); + static const int kRafInfoTagFieldNumber = 5; + inline ::google::protobuf::uint32 raf_info_tag() const; + inline void set_raf_info_tag(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountFieldTags) + private: + inline void set_has_game_level_info_tag(); + inline void clear_has_game_level_info_tag(); + inline void set_has_game_time_info_tag(); + inline void clear_has_game_time_info_tag(); + inline void set_has_game_status_tag(); + inline void clear_has_game_status_tag(); + inline void set_has_raf_info_tag(); + inline void clear_has_raf_info_tag(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 game_level_info_tag_; + ::google::protobuf::uint32 game_time_info_tag_; + ::google::protobuf::uint32 game_status_tag_; + ::google::protobuf::uint32 raf_info_tag_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static GameAccountFieldTags* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API AccountFieldOptions : public ::google::protobuf::Message { + public: + AccountFieldOptions(); + virtual ~AccountFieldOptions(); + + AccountFieldOptions(const AccountFieldOptions& from); + + inline AccountFieldOptions& operator=(const AccountFieldOptions& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AccountFieldOptions& default_instance(); + + void Swap(AccountFieldOptions* other); + + // implements Message ---------------------------------------------- + + AccountFieldOptions* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AccountFieldOptions& from); + void MergeFrom(const AccountFieldOptions& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional bool all_fields = 1; + inline bool has_all_fields() const; + inline void clear_all_fields(); + static const int kAllFieldsFieldNumber = 1; + inline bool all_fields() const; + inline void set_all_fields(bool value); + + // optional bool field_account_level_info = 2; + inline bool has_field_account_level_info() const; + inline void clear_field_account_level_info(); + static const int kFieldAccountLevelInfoFieldNumber = 2; + inline bool field_account_level_info() const; + inline void set_field_account_level_info(bool value); + + // optional bool field_privacy_info = 3; + inline bool has_field_privacy_info() const; + inline void clear_field_privacy_info(); + static const int kFieldPrivacyInfoFieldNumber = 3; + inline bool field_privacy_info() const; + inline void set_field_privacy_info(bool value); + + // optional bool field_parental_control_info = 4; + inline bool has_field_parental_control_info() const; + inline void clear_field_parental_control_info(); + static const int kFieldParentalControlInfoFieldNumber = 4; + inline bool field_parental_control_info() const; + inline void set_field_parental_control_info(bool value); + + // optional bool field_game_level_info = 6; + inline bool has_field_game_level_info() const; + inline void clear_field_game_level_info(); + static const int kFieldGameLevelInfoFieldNumber = 6; + inline bool field_game_level_info() const; + inline void set_field_game_level_info(bool value); + + // optional bool field_game_status = 7; + inline bool has_field_game_status() const; + inline void clear_field_game_status(); + static const int kFieldGameStatusFieldNumber = 7; + inline bool field_game_status() const; + inline void set_field_game_status(bool value); + + // optional bool field_game_accounts = 8; + inline bool has_field_game_accounts() const; + inline void clear_field_game_accounts(); + static const int kFieldGameAccountsFieldNumber = 8; + inline bool field_game_accounts() const; + inline void set_field_game_accounts(bool value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountFieldOptions) + private: + inline void set_has_all_fields(); + inline void clear_has_all_fields(); + inline void set_has_field_account_level_info(); + inline void clear_has_field_account_level_info(); + inline void set_has_field_privacy_info(); + inline void clear_has_field_privacy_info(); + inline void set_has_field_parental_control_info(); + inline void clear_has_field_parental_control_info(); + inline void set_has_field_game_level_info(); + inline void clear_has_field_game_level_info(); + inline void set_has_field_game_status(); + inline void clear_has_field_game_status(); + inline void set_has_field_game_accounts(); + inline void clear_has_field_game_accounts(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + bool all_fields_; + bool field_account_level_info_; + bool field_privacy_info_; + bool field_parental_control_info_; + bool field_game_level_info_; + bool field_game_status_; + bool field_game_accounts_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static AccountFieldOptions* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GameAccountFieldOptions : public ::google::protobuf::Message { + public: + GameAccountFieldOptions(); + virtual ~GameAccountFieldOptions(); + + GameAccountFieldOptions(const GameAccountFieldOptions& from); + + inline GameAccountFieldOptions& operator=(const GameAccountFieldOptions& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GameAccountFieldOptions& default_instance(); + + void Swap(GameAccountFieldOptions* other); + + // implements Message ---------------------------------------------- + + GameAccountFieldOptions* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GameAccountFieldOptions& from); + void MergeFrom(const GameAccountFieldOptions& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional bool all_fields = 1; + inline bool has_all_fields() const; + inline void clear_all_fields(); + static const int kAllFieldsFieldNumber = 1; + inline bool all_fields() const; + inline void set_all_fields(bool value); + + // optional bool field_game_level_info = 2; + inline bool has_field_game_level_info() const; + inline void clear_field_game_level_info(); + static const int kFieldGameLevelInfoFieldNumber = 2; + inline bool field_game_level_info() const; + inline void set_field_game_level_info(bool value); + + // optional bool field_game_time_info = 3; + inline bool has_field_game_time_info() const; + inline void clear_field_game_time_info(); + static const int kFieldGameTimeInfoFieldNumber = 3; + inline bool field_game_time_info() const; + inline void set_field_game_time_info(bool value); + + // optional bool field_game_status = 4; + inline bool has_field_game_status() const; + inline void clear_field_game_status(); + static const int kFieldGameStatusFieldNumber = 4; + inline bool field_game_status() const; + inline void set_field_game_status(bool value); + + // optional bool field_raf_info = 5; + inline bool has_field_raf_info() const; + inline void clear_field_raf_info(); + static const int kFieldRafInfoFieldNumber = 5; + inline bool field_raf_info() const; + inline void set_field_raf_info(bool value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountFieldOptions) + private: + inline void set_has_all_fields(); + inline void clear_has_all_fields(); + inline void set_has_field_game_level_info(); + inline void clear_has_field_game_level_info(); + inline void set_has_field_game_time_info(); + inline void clear_has_field_game_time_info(); + inline void set_has_field_game_status(); + inline void clear_has_field_game_status(); + inline void set_has_field_raf_info(); + inline void clear_has_field_raf_info(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + bool all_fields_; + bool field_game_level_info_; + bool field_game_time_info_; + bool field_game_status_; + bool field_raf_info_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static GameAccountFieldOptions* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API SubscriberReference : public ::google::protobuf::Message { + public: + SubscriberReference(); + virtual ~SubscriberReference(); + + SubscriberReference(const SubscriberReference& from); + + inline SubscriberReference& operator=(const SubscriberReference& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SubscriberReference& default_instance(); + + void Swap(SubscriberReference* other); + + // implements Message ---------------------------------------------- + + SubscriberReference* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SubscriberReference& from); + void MergeFrom(const SubscriberReference& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint64 object_id = 1 [default = 0]; + inline bool has_object_id() const; + inline void clear_object_id(); + static const int kObjectIdFieldNumber = 1; + inline ::google::protobuf::uint64 object_id() const; + inline void set_object_id(::google::protobuf::uint64 value); + + // optional .bgs.protocol.EntityId entity_id = 2; + inline bool has_entity_id() const; + inline void clear_entity_id(); + static const int kEntityIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& entity_id() const; + inline ::bgs::protocol::EntityId* mutable_entity_id(); + inline ::bgs::protocol::EntityId* release_entity_id(); + inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id); + + // optional .bgs.protocol.account.v1.AccountFieldOptions account_options = 3; + inline bool has_account_options() const; + inline void clear_account_options(); + static const int kAccountOptionsFieldNumber = 3; + inline const ::bgs::protocol::account::v1::AccountFieldOptions& account_options() const; + inline ::bgs::protocol::account::v1::AccountFieldOptions* mutable_account_options(); + inline ::bgs::protocol::account::v1::AccountFieldOptions* release_account_options(); + inline void set_allocated_account_options(::bgs::protocol::account::v1::AccountFieldOptions* account_options); + + // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 4; + inline bool has_account_tags() const; + inline void clear_account_tags(); + static const int kAccountTagsFieldNumber = 4; + inline const ::bgs::protocol::account::v1::AccountFieldTags& account_tags() const; + inline ::bgs::protocol::account::v1::AccountFieldTags* mutable_account_tags(); + inline ::bgs::protocol::account::v1::AccountFieldTags* release_account_tags(); + inline void set_allocated_account_tags(::bgs::protocol::account::v1::AccountFieldTags* account_tags); + + // optional .bgs.protocol.account.v1.GameAccountFieldOptions game_account_options = 5; + inline bool has_game_account_options() const; + inline void clear_game_account_options(); + static const int kGameAccountOptionsFieldNumber = 5; + inline const ::bgs::protocol::account::v1::GameAccountFieldOptions& game_account_options() const; + inline ::bgs::protocol::account::v1::GameAccountFieldOptions* mutable_game_account_options(); + inline ::bgs::protocol::account::v1::GameAccountFieldOptions* release_game_account_options(); + inline void set_allocated_game_account_options(::bgs::protocol::account::v1::GameAccountFieldOptions* game_account_options); + + // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 6; + inline bool has_game_account_tags() const; + inline void clear_game_account_tags(); + static const int kGameAccountTagsFieldNumber = 6; + inline const ::bgs::protocol::account::v1::GameAccountFieldTags& game_account_tags() const; + inline ::bgs::protocol::account::v1::GameAccountFieldTags* mutable_game_account_tags(); + inline ::bgs::protocol::account::v1::GameAccountFieldTags* release_game_account_tags(); + inline void set_allocated_game_account_tags(::bgs::protocol::account::v1::GameAccountFieldTags* game_account_tags); + + // optional uint64 subscriber_id = 7 [default = 0]; + inline bool has_subscriber_id() const; + inline void clear_subscriber_id(); + static const int kSubscriberIdFieldNumber = 7; + inline ::google::protobuf::uint64 subscriber_id() const; + inline void set_subscriber_id(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.SubscriberReference) + private: + inline void set_has_object_id(); + inline void clear_has_object_id(); + inline void set_has_entity_id(); + inline void clear_has_entity_id(); + inline void set_has_account_options(); + inline void clear_has_account_options(); + inline void set_has_account_tags(); + inline void clear_has_account_tags(); + inline void set_has_game_account_options(); + inline void clear_has_game_account_options(); + inline void set_has_game_account_tags(); + inline void clear_has_game_account_tags(); + inline void set_has_subscriber_id(); + inline void clear_has_subscriber_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint64 object_id_; + ::bgs::protocol::EntityId* entity_id_; + ::bgs::protocol::account::v1::AccountFieldOptions* account_options_; + ::bgs::protocol::account::v1::AccountFieldTags* account_tags_; + ::bgs::protocol::account::v1::GameAccountFieldOptions* game_account_options_; + ::bgs::protocol::account::v1::GameAccountFieldTags* game_account_tags_; + ::google::protobuf::uint64 subscriber_id_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static SubscriberReference* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API AccountLevelInfo : public ::google::protobuf::Message { + public: + AccountLevelInfo(); + virtual ~AccountLevelInfo(); + + AccountLevelInfo(const AccountLevelInfo& from); + + inline AccountLevelInfo& operator=(const AccountLevelInfo& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AccountLevelInfo& default_instance(); + + void Swap(AccountLevelInfo* other); + + // implements Message ---------------------------------------------- + + AccountLevelInfo* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AccountLevelInfo& from); + void MergeFrom(const AccountLevelInfo& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 3; + inline int licenses_size() const; + inline void clear_licenses(); + static const int kLicensesFieldNumber = 3; + inline const ::bgs::protocol::account::v1::AccountLicense& licenses(int index) const; + inline ::bgs::protocol::account::v1::AccountLicense* mutable_licenses(int index); + inline ::bgs::protocol::account::v1::AccountLicense* add_licenses(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >& + licenses() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >* + mutable_licenses(); + + // optional fixed32 default_currency = 4; + inline bool has_default_currency() const; + inline void clear_default_currency(); + static const int kDefaultCurrencyFieldNumber = 4; + inline ::google::protobuf::uint32 default_currency() const; + inline void set_default_currency(::google::protobuf::uint32 value); + + // optional string country = 5; + inline bool has_country() const; + inline void clear_country(); + static const int kCountryFieldNumber = 5; + inline const ::std::string& country() const; + inline void set_country(const ::std::string& value); + inline void set_country(const char* value); + inline void set_country(const char* value, size_t size); + inline ::std::string* mutable_country(); + inline ::std::string* release_country(); + inline void set_allocated_country(::std::string* country); + + // optional uint32 preferred_region = 6; + inline bool has_preferred_region() const; + inline void clear_preferred_region(); + static const int kPreferredRegionFieldNumber = 6; + inline ::google::protobuf::uint32 preferred_region() const; + inline void set_preferred_region(::google::protobuf::uint32 value); + + // optional string full_name = 7; + inline bool has_full_name() const; + inline void clear_full_name(); + static const int kFullNameFieldNumber = 7; + inline const ::std::string& full_name() const; + inline void set_full_name(const ::std::string& value); + inline void set_full_name(const char* value); + inline void set_full_name(const char* value, size_t size); + inline ::std::string* mutable_full_name(); + inline ::std::string* release_full_name(); + inline void set_allocated_full_name(::std::string* full_name); + + // optional string battle_tag = 8; + inline bool has_battle_tag() const; + inline void clear_battle_tag(); + static const int kBattleTagFieldNumber = 8; + inline const ::std::string& battle_tag() const; + inline void set_battle_tag(const ::std::string& value); + inline void set_battle_tag(const char* value); + inline void set_battle_tag(const char* value, size_t size); + inline ::std::string* mutable_battle_tag(); + inline ::std::string* release_battle_tag(); + inline void set_allocated_battle_tag(::std::string* battle_tag); + + // optional bool muted = 9; + inline bool has_muted() const; + inline void clear_muted(); + static const int kMutedFieldNumber = 9; + inline bool muted() const; + inline void set_muted(bool value); + + // optional bool manual_review = 10; + inline bool has_manual_review() const; + inline void clear_manual_review(); + static const int kManualReviewFieldNumber = 10; + inline bool manual_review() const; + inline void set_manual_review(bool value); + + // optional bool account_paid_any = 11; + inline bool has_account_paid_any() const; + inline void clear_account_paid_any(); + static const int kAccountPaidAnyFieldNumber = 11; + inline bool account_paid_any() const; + inline void set_account_paid_any(bool value); + + // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 12; + inline bool has_identity_check_status() const; + inline void clear_identity_check_status(); + static const int kIdentityCheckStatusFieldNumber = 12; + inline ::bgs::protocol::account::v1::IdentityVerificationStatus identity_check_status() const; + inline void set_identity_check_status(::bgs::protocol::account::v1::IdentityVerificationStatus value); + + // optional string email = 13; + inline bool has_email() const; + inline void clear_email(); + static const int kEmailFieldNumber = 13; + inline const ::std::string& email() const; + inline void set_email(const ::std::string& value); + inline void set_email(const char* value); + inline void set_email(const char* value, size_t size); + inline ::std::string* mutable_email(); + inline ::std::string* release_email(); + inline void set_allocated_email(::std::string* email); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountLevelInfo) + private: + inline void set_has_default_currency(); + inline void clear_has_default_currency(); + inline void set_has_country(); + inline void clear_has_country(); + inline void set_has_preferred_region(); + inline void clear_has_preferred_region(); + inline void set_has_full_name(); + inline void clear_has_full_name(); + inline void set_has_battle_tag(); + inline void clear_has_battle_tag(); + inline void set_has_muted(); + inline void clear_has_muted(); + inline void set_has_manual_review(); + inline void clear_has_manual_review(); + inline void set_has_account_paid_any(); + inline void clear_has_account_paid_any(); + inline void set_has_identity_check_status(); + inline void clear_has_identity_check_status(); + inline void set_has_email(); + inline void clear_has_email(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense > licenses_; + ::std::string* country_; + ::google::protobuf::uint32 default_currency_; + ::google::protobuf::uint32 preferred_region_; + ::std::string* full_name_; + ::std::string* battle_tag_; + bool muted_; + bool manual_review_; + bool account_paid_any_; + int identity_check_status_; + ::std::string* email_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static AccountLevelInfo* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API PrivacyInfo : public ::google::protobuf::Message { + public: + PrivacyInfo(); + virtual ~PrivacyInfo(); + + PrivacyInfo(const PrivacyInfo& from); + + inline PrivacyInfo& operator=(const PrivacyInfo& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const PrivacyInfo& default_instance(); + + void Swap(PrivacyInfo* other); + + // implements Message ---------------------------------------------- + + PrivacyInfo* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const PrivacyInfo& from); + void MergeFrom(const PrivacyInfo& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef PrivacyInfo_GameInfoPrivacy GameInfoPrivacy; + static const GameInfoPrivacy PRIVACY_ME = PrivacyInfo_GameInfoPrivacy_PRIVACY_ME; + static const GameInfoPrivacy PRIVACY_FRIENDS = PrivacyInfo_GameInfoPrivacy_PRIVACY_FRIENDS; + static const GameInfoPrivacy PRIVACY_EVERYONE = PrivacyInfo_GameInfoPrivacy_PRIVACY_EVERYONE; + static inline bool GameInfoPrivacy_IsValid(int value) { + return PrivacyInfo_GameInfoPrivacy_IsValid(value); + } + static const GameInfoPrivacy GameInfoPrivacy_MIN = + PrivacyInfo_GameInfoPrivacy_GameInfoPrivacy_MIN; + static const GameInfoPrivacy GameInfoPrivacy_MAX = + PrivacyInfo_GameInfoPrivacy_GameInfoPrivacy_MAX; + static const int GameInfoPrivacy_ARRAYSIZE = + PrivacyInfo_GameInfoPrivacy_GameInfoPrivacy_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + GameInfoPrivacy_descriptor() { + return PrivacyInfo_GameInfoPrivacy_descriptor(); + } + static inline const ::std::string& GameInfoPrivacy_Name(GameInfoPrivacy value) { + return PrivacyInfo_GameInfoPrivacy_Name(value); + } + static inline bool GameInfoPrivacy_Parse(const ::std::string& name, + GameInfoPrivacy* value) { + return PrivacyInfo_GameInfoPrivacy_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // optional bool is_using_rid = 3; + inline bool has_is_using_rid() const; + inline void clear_is_using_rid(); + static const int kIsUsingRidFieldNumber = 3; + inline bool is_using_rid() const; + inline void set_is_using_rid(bool value); + + // optional bool is_real_id_visible_for_view_friends = 4; + inline bool has_is_real_id_visible_for_view_friends() const; + inline void clear_is_real_id_visible_for_view_friends(); + static const int kIsRealIdVisibleForViewFriendsFieldNumber = 4; + inline bool is_real_id_visible_for_view_friends() const; + inline void set_is_real_id_visible_for_view_friends(bool value); + + // optional bool is_hidden_from_friend_finder = 5; + inline bool has_is_hidden_from_friend_finder() const; + inline void clear_is_hidden_from_friend_finder(); + static const int kIsHiddenFromFriendFinderFieldNumber = 5; + inline bool is_hidden_from_friend_finder() const; + inline void set_is_hidden_from_friend_finder(bool value); + + // optional .bgs.protocol.account.v1.PrivacyInfo.GameInfoPrivacy game_info_privacy = 6 [default = PRIVACY_FRIENDS]; + inline bool has_game_info_privacy() const; + inline void clear_game_info_privacy(); + static const int kGameInfoPrivacyFieldNumber = 6; + inline ::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy game_info_privacy() const; + inline void set_game_info_privacy(::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.PrivacyInfo) + private: + inline void set_has_is_using_rid(); + inline void clear_has_is_using_rid(); + inline void set_has_is_real_id_visible_for_view_friends(); + inline void clear_has_is_real_id_visible_for_view_friends(); + inline void set_has_is_hidden_from_friend_finder(); + inline void clear_has_is_hidden_from_friend_finder(); + inline void set_has_game_info_privacy(); + inline void clear_has_game_info_privacy(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + bool is_using_rid_; + bool is_real_id_visible_for_view_friends_; + bool is_hidden_from_friend_finder_; + int game_info_privacy_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static PrivacyInfo* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ParentalControlInfo : public ::google::protobuf::Message { + public: + ParentalControlInfo(); + virtual ~ParentalControlInfo(); + + ParentalControlInfo(const ParentalControlInfo& from); + + inline ParentalControlInfo& operator=(const ParentalControlInfo& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ParentalControlInfo& default_instance(); + + void Swap(ParentalControlInfo* other); + + // implements Message ---------------------------------------------- + + ParentalControlInfo* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ParentalControlInfo& from); + void MergeFrom(const ParentalControlInfo& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string timezone = 3; + inline bool has_timezone() const; + inline void clear_timezone(); + static const int kTimezoneFieldNumber = 3; + inline const ::std::string& timezone() const; + inline void set_timezone(const ::std::string& value); + inline void set_timezone(const char* value); + inline void set_timezone(const char* value, size_t size); + inline ::std::string* mutable_timezone(); + inline ::std::string* release_timezone(); + inline void set_allocated_timezone(::std::string* timezone); + + // optional uint32 minutes_per_day = 4; + inline bool has_minutes_per_day() const; + inline void clear_minutes_per_day(); + static const int kMinutesPerDayFieldNumber = 4; + inline ::google::protobuf::uint32 minutes_per_day() const; + inline void set_minutes_per_day(::google::protobuf::uint32 value); + + // optional uint32 minutes_per_week = 5; + inline bool has_minutes_per_week() const; + inline void clear_minutes_per_week(); + static const int kMinutesPerWeekFieldNumber = 5; + inline ::google::protobuf::uint32 minutes_per_week() const; + inline void set_minutes_per_week(::google::protobuf::uint32 value); + + // optional bool can_receive_voice = 6; + inline bool has_can_receive_voice() const; + inline void clear_can_receive_voice(); + static const int kCanReceiveVoiceFieldNumber = 6; + inline bool can_receive_voice() const; + inline void set_can_receive_voice(bool value); + + // optional bool can_send_voice = 7; + inline bool has_can_send_voice() const; + inline void clear_can_send_voice(); + static const int kCanSendVoiceFieldNumber = 7; + inline bool can_send_voice() const; + inline void set_can_send_voice(bool value); + + // repeated bool play_schedule = 8; + inline int play_schedule_size() const; + inline void clear_play_schedule(); + static const int kPlayScheduleFieldNumber = 8; + inline bool play_schedule(int index) const; + inline void set_play_schedule(int index, bool value); + inline void add_play_schedule(bool value); + inline const ::google::protobuf::RepeatedField< bool >& + play_schedule() const; + inline ::google::protobuf::RepeatedField< bool >* + mutable_play_schedule(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.ParentalControlInfo) + private: + inline void set_has_timezone(); + inline void clear_has_timezone(); + inline void set_has_minutes_per_day(); + inline void clear_has_minutes_per_day(); + inline void set_has_minutes_per_week(); + inline void clear_has_minutes_per_week(); + inline void set_has_can_receive_voice(); + inline void clear_has_can_receive_voice(); + inline void set_has_can_send_voice(); + inline void clear_has_can_send_voice(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* timezone_; + ::google::protobuf::uint32 minutes_per_day_; + ::google::protobuf::uint32 minutes_per_week_; + ::google::protobuf::RepeatedField< bool > play_schedule_; + bool can_receive_voice_; + bool can_send_voice_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static ParentalControlInfo* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GameLevelInfo : public ::google::protobuf::Message { + public: + GameLevelInfo(); + virtual ~GameLevelInfo(); + + GameLevelInfo(const GameLevelInfo& from); + + inline GameLevelInfo& operator=(const GameLevelInfo& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GameLevelInfo& default_instance(); + + void Swap(GameLevelInfo* other); + + // implements Message ---------------------------------------------- + + GameLevelInfo* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GameLevelInfo& from); + void MergeFrom(const GameLevelInfo& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional bool is_trial = 4; + inline bool has_is_trial() const; + inline void clear_is_trial(); + static const int kIsTrialFieldNumber = 4; + inline bool is_trial() const; + inline void set_is_trial(bool value); + + // optional bool is_lifetime = 5; + inline bool has_is_lifetime() const; + inline void clear_is_lifetime(); + static const int kIsLifetimeFieldNumber = 5; + inline bool is_lifetime() const; + inline void set_is_lifetime(bool value); + + // optional bool is_restricted = 6; + inline bool has_is_restricted() const; + inline void clear_is_restricted(); + static const int kIsRestrictedFieldNumber = 6; + inline bool is_restricted() const; + inline void set_is_restricted(bool value); + + // optional bool is_beta = 7; + inline bool has_is_beta() const; + inline void clear_is_beta(); + static const int kIsBetaFieldNumber = 7; + inline bool is_beta() const; + inline void set_is_beta(bool value); + + // optional string name = 8; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 8; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + inline ::std::string* release_name(); + inline void set_allocated_name(::std::string* name); + + // optional fixed32 program = 9; + inline bool has_program() const; + inline void clear_program(); + static const int kProgramFieldNumber = 9; + inline ::google::protobuf::uint32 program() const; + inline void set_program(::google::protobuf::uint32 value); + + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 10; + inline int licenses_size() const; + inline void clear_licenses(); + static const int kLicensesFieldNumber = 10; + inline const ::bgs::protocol::account::v1::AccountLicense& licenses(int index) const; + inline ::bgs::protocol::account::v1::AccountLicense* mutable_licenses(int index); + inline ::bgs::protocol::account::v1::AccountLicense* add_licenses(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >& + licenses() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >* + mutable_licenses(); + + // optional uint32 realm_permissions = 11; + inline bool has_realm_permissions() const; + inline void clear_realm_permissions(); + static const int kRealmPermissionsFieldNumber = 11; + inline ::google::protobuf::uint32 realm_permissions() const; + inline void set_realm_permissions(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameLevelInfo) + private: + inline void set_has_is_trial(); + inline void clear_has_is_trial(); + inline void set_has_is_lifetime(); + inline void clear_has_is_lifetime(); + inline void set_has_is_restricted(); + inline void clear_has_is_restricted(); + inline void set_has_is_beta(); + inline void clear_has_is_beta(); + inline void set_has_name(); + inline void clear_has_name(); + inline void set_has_program(); + inline void clear_has_program(); + inline void set_has_realm_permissions(); + inline void clear_has_realm_permissions(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + bool is_trial_; + bool is_lifetime_; + bool is_restricted_; + bool is_beta_; + ::google::protobuf::uint32 program_; + ::std::string* name_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense > licenses_; + ::google::protobuf::uint32 realm_permissions_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static GameLevelInfo* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GameTimeInfo : public ::google::protobuf::Message { + public: + GameTimeInfo(); + virtual ~GameTimeInfo(); + + GameTimeInfo(const GameTimeInfo& from); + + inline GameTimeInfo& operator=(const GameTimeInfo& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GameTimeInfo& default_instance(); + + void Swap(GameTimeInfo* other); + + // implements Message ---------------------------------------------- + + GameTimeInfo* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GameTimeInfo& from); + void MergeFrom(const GameTimeInfo& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional bool is_unlimited_play_time = 3; + inline bool has_is_unlimited_play_time() const; + inline void clear_is_unlimited_play_time(); + static const int kIsUnlimitedPlayTimeFieldNumber = 3; + inline bool is_unlimited_play_time() const; + inline void set_is_unlimited_play_time(bool value); + + // optional uint64 play_time_expires = 5; + inline bool has_play_time_expires() const; + inline void clear_play_time_expires(); + static const int kPlayTimeExpiresFieldNumber = 5; + inline ::google::protobuf::uint64 play_time_expires() const; + inline void set_play_time_expires(::google::protobuf::uint64 value); + + // optional bool is_subscription = 6; + inline bool has_is_subscription() const; + inline void clear_is_subscription(); + static const int kIsSubscriptionFieldNumber = 6; + inline bool is_subscription() const; + inline void set_is_subscription(bool value); + + // optional bool is_recurring_subscription = 7; + inline bool has_is_recurring_subscription() const; + inline void clear_is_recurring_subscription(); + static const int kIsRecurringSubscriptionFieldNumber = 7; + inline bool is_recurring_subscription() const; + inline void set_is_recurring_subscription(bool value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameTimeInfo) + private: + inline void set_has_is_unlimited_play_time(); + inline void clear_has_is_unlimited_play_time(); + inline void set_has_play_time_expires(); + inline void clear_has_play_time_expires(); + inline void set_has_is_subscription(); + inline void clear_has_is_subscription(); + inline void set_has_is_recurring_subscription(); + inline void clear_has_is_recurring_subscription(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint64 play_time_expires_; + bool is_unlimited_play_time_; + bool is_subscription_; + bool is_recurring_subscription_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static GameTimeInfo* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GameTimeRemainingInfo : public ::google::protobuf::Message { + public: + GameTimeRemainingInfo(); + virtual ~GameTimeRemainingInfo(); + + GameTimeRemainingInfo(const GameTimeRemainingInfo& from); + + inline GameTimeRemainingInfo& operator=(const GameTimeRemainingInfo& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GameTimeRemainingInfo& default_instance(); + + void Swap(GameTimeRemainingInfo* other); + + // implements Message ---------------------------------------------- + + GameTimeRemainingInfo* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GameTimeRemainingInfo& from); + void MergeFrom(const GameTimeRemainingInfo& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint32 minutes_remaining = 1; + inline bool has_minutes_remaining() const; + inline void clear_minutes_remaining(); + static const int kMinutesRemainingFieldNumber = 1; + inline ::google::protobuf::uint32 minutes_remaining() const; + inline void set_minutes_remaining(::google::protobuf::uint32 value); + + // optional uint32 parental_daily_minutes_remaining = 2; + inline bool has_parental_daily_minutes_remaining() const; + inline void clear_parental_daily_minutes_remaining(); + static const int kParentalDailyMinutesRemainingFieldNumber = 2; + inline ::google::protobuf::uint32 parental_daily_minutes_remaining() const; + inline void set_parental_daily_minutes_remaining(::google::protobuf::uint32 value); + + // optional uint32 parental_weekly_minutes_remaining = 3; + inline bool has_parental_weekly_minutes_remaining() const; + inline void clear_parental_weekly_minutes_remaining(); + static const int kParentalWeeklyMinutesRemainingFieldNumber = 3; + inline ::google::protobuf::uint32 parental_weekly_minutes_remaining() const; + inline void set_parental_weekly_minutes_remaining(::google::protobuf::uint32 value); + + // optional uint32 seconds_remaining_until_kick = 4; + inline bool has_seconds_remaining_until_kick() const; + inline void clear_seconds_remaining_until_kick(); + static const int kSecondsRemainingUntilKickFieldNumber = 4; + inline ::google::protobuf::uint32 seconds_remaining_until_kick() const; + inline void set_seconds_remaining_until_kick(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameTimeRemainingInfo) + private: + inline void set_has_minutes_remaining(); + inline void clear_has_minutes_remaining(); + inline void set_has_parental_daily_minutes_remaining(); + inline void clear_has_parental_daily_minutes_remaining(); + inline void set_has_parental_weekly_minutes_remaining(); + inline void clear_has_parental_weekly_minutes_remaining(); + inline void set_has_seconds_remaining_until_kick(); + inline void clear_has_seconds_remaining_until_kick(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 minutes_remaining_; + ::google::protobuf::uint32 parental_daily_minutes_remaining_; + ::google::protobuf::uint32 parental_weekly_minutes_remaining_; + ::google::protobuf::uint32 seconds_remaining_until_kick_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static GameTimeRemainingInfo* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GameStatus : public ::google::protobuf::Message { + public: + GameStatus(); + virtual ~GameStatus(); + + GameStatus(const GameStatus& from); + + inline GameStatus& operator=(const GameStatus& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GameStatus& default_instance(); + + void Swap(GameStatus* other); + + // implements Message ---------------------------------------------- + + GameStatus* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GameStatus& from); + void MergeFrom(const GameStatus& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional bool is_suspended = 4; + inline bool has_is_suspended() const; + inline void clear_is_suspended(); + static const int kIsSuspendedFieldNumber = 4; + inline bool is_suspended() const; + inline void set_is_suspended(bool value); + + // optional bool is_banned = 5; + inline bool has_is_banned() const; + inline void clear_is_banned(); + static const int kIsBannedFieldNumber = 5; + inline bool is_banned() const; + inline void set_is_banned(bool value); + + // optional uint64 suspension_expires = 6; + inline bool has_suspension_expires() const; + inline void clear_suspension_expires(); + static const int kSuspensionExpiresFieldNumber = 6; + inline ::google::protobuf::uint64 suspension_expires() const; + inline void set_suspension_expires(::google::protobuf::uint64 value); + + // optional fixed32 program = 7; + inline bool has_program() const; + inline void clear_program(); + static const int kProgramFieldNumber = 7; + inline ::google::protobuf::uint32 program() const; + inline void set_program(::google::protobuf::uint32 value); + + // optional bool is_locked = 8; + inline bool has_is_locked() const; + inline void clear_is_locked(); + static const int kIsLockedFieldNumber = 8; + inline bool is_locked() const; + inline void set_is_locked(bool value); + + // optional bool is_bam_unlockable = 9; + inline bool has_is_bam_unlockable() const; + inline void clear_is_bam_unlockable(); + static const int kIsBamUnlockableFieldNumber = 9; + inline bool is_bam_unlockable() const; + inline void set_is_bam_unlockable(bool value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameStatus) + private: + inline void set_has_is_suspended(); + inline void clear_has_is_suspended(); + inline void set_has_is_banned(); + inline void clear_has_is_banned(); + inline void set_has_suspension_expires(); + inline void clear_has_suspension_expires(); + inline void set_has_program(); + inline void clear_has_program(); + inline void set_has_is_locked(); + inline void clear_has_is_locked(); + inline void set_has_is_bam_unlockable(); + inline void clear_has_is_bam_unlockable(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint64 suspension_expires_; + bool is_suspended_; + bool is_banned_; + bool is_locked_; + bool is_bam_unlockable_; + ::google::protobuf::uint32 program_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static GameStatus* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API RAFInfo : public ::google::protobuf::Message { + public: + RAFInfo(); + virtual ~RAFInfo(); + + RAFInfo(const RAFInfo& from); + + inline RAFInfo& operator=(const RAFInfo& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const RAFInfo& default_instance(); + + void Swap(RAFInfo* other); + + // implements Message ---------------------------------------------- + + RAFInfo* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const RAFInfo& from); + void MergeFrom(const RAFInfo& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional bytes raf_info = 1; + inline bool has_raf_info() const; + inline void clear_raf_info(); + static const int kRafInfoFieldNumber = 1; + inline const ::std::string& raf_info() const; + inline void set_raf_info(const ::std::string& value); + inline void set_raf_info(const char* value); + inline void set_raf_info(const void* value, size_t size); + inline ::std::string* mutable_raf_info(); + inline ::std::string* release_raf_info(); + inline void set_allocated_raf_info(::std::string* raf_info); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.RAFInfo) + private: + inline void set_has_raf_info(); + inline void clear_has_raf_info(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* raf_info_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static RAFInfo* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GameSessionInfo : public ::google::protobuf::Message { + public: + GameSessionInfo(); + virtual ~GameSessionInfo(); + + GameSessionInfo(const GameSessionInfo& from); + + inline GameSessionInfo& operator=(const GameSessionInfo& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GameSessionInfo& default_instance(); + + void Swap(GameSessionInfo* other); + + // implements Message ---------------------------------------------- + + GameSessionInfo* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GameSessionInfo& from); + void MergeFrom(const GameSessionInfo& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint32 start_time = 3 [deprecated = true]; + inline bool has_start_time() const PROTOBUF_DEPRECATED; + inline void clear_start_time() PROTOBUF_DEPRECATED; + static const int kStartTimeFieldNumber = 3; + inline ::google::protobuf::uint32 start_time() const PROTOBUF_DEPRECATED; + inline void set_start_time(::google::protobuf::uint32 value) PROTOBUF_DEPRECATED; + + // optional .bgs.protocol.account.v1.GameSessionLocation location = 4; + inline bool has_location() const; + inline void clear_location(); + static const int kLocationFieldNumber = 4; + inline const ::bgs::protocol::account::v1::GameSessionLocation& location() const; + inline ::bgs::protocol::account::v1::GameSessionLocation* mutable_location(); + inline ::bgs::protocol::account::v1::GameSessionLocation* release_location(); + inline void set_allocated_location(::bgs::protocol::account::v1::GameSessionLocation* location); + + // optional bool has_benefactor = 5; + inline bool has_has_benefactor() const; + inline void clear_has_benefactor(); + static const int kHasBenefactorFieldNumber = 5; + inline bool has_benefactor() const; + inline void set_has_benefactor(bool value); + + // optional bool is_using_igr = 6; + inline bool has_is_using_igr() const; + inline void clear_is_using_igr(); + static const int kIsUsingIgrFieldNumber = 6; + inline bool is_using_igr() const; + inline void set_is_using_igr(bool value); + + // optional bool parental_controls_active = 7; + inline bool has_parental_controls_active() const; + inline void clear_parental_controls_active(); + static const int kParentalControlsActiveFieldNumber = 7; + inline bool parental_controls_active() const; + inline void set_parental_controls_active(bool value); + + // optional uint64 start_time_sec = 8; + inline bool has_start_time_sec() const; + inline void clear_start_time_sec(); + static const int kStartTimeSecFieldNumber = 8; + inline ::google::protobuf::uint64 start_time_sec() const; + inline void set_start_time_sec(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameSessionInfo) + private: + inline void set_has_start_time(); + inline void clear_has_start_time(); + inline void set_has_location(); + inline void clear_has_location(); + inline void set_has_has_benefactor(); + inline void clear_has_has_benefactor(); + inline void set_has_is_using_igr(); + inline void clear_has_is_using_igr(); + inline void set_has_parental_controls_active(); + inline void clear_has_parental_controls_active(); + inline void set_has_start_time_sec(); + inline void clear_has_start_time_sec(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::account::v1::GameSessionLocation* location_; + ::google::protobuf::uint32 start_time_; + bool has_benefactor_; + bool is_using_igr_; + bool parental_controls_active_; + ::google::protobuf::uint64 start_time_sec_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static GameSessionInfo* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GameSessionUpdateInfo : public ::google::protobuf::Message { + public: + GameSessionUpdateInfo(); + virtual ~GameSessionUpdateInfo(); + + GameSessionUpdateInfo(const GameSessionUpdateInfo& from); + + inline GameSessionUpdateInfo& operator=(const GameSessionUpdateInfo& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GameSessionUpdateInfo& default_instance(); + + void Swap(GameSessionUpdateInfo* other); + + // implements Message ---------------------------------------------- + + GameSessionUpdateInfo* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GameSessionUpdateInfo& from); + void MergeFrom(const GameSessionUpdateInfo& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.account.v1.CAIS cais = 8; + inline bool has_cais() const; + inline void clear_cais(); + static const int kCaisFieldNumber = 8; + inline const ::bgs::protocol::account::v1::CAIS& cais() const; + inline ::bgs::protocol::account::v1::CAIS* mutable_cais(); + inline ::bgs::protocol::account::v1::CAIS* release_cais(); + inline void set_allocated_cais(::bgs::protocol::account::v1::CAIS* cais); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameSessionUpdateInfo) + private: + inline void set_has_cais(); + inline void clear_has_cais(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::account::v1::CAIS* cais_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static GameSessionUpdateInfo* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GameSessionLocation : public ::google::protobuf::Message { + public: + GameSessionLocation(); + virtual ~GameSessionLocation(); + + GameSessionLocation(const GameSessionLocation& from); + + inline GameSessionLocation& operator=(const GameSessionLocation& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GameSessionLocation& default_instance(); + + void Swap(GameSessionLocation* other); + + // implements Message ---------------------------------------------- + + GameSessionLocation* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GameSessionLocation& from); + void MergeFrom(const GameSessionLocation& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string ip_address = 1; + inline bool has_ip_address() const; + inline void clear_ip_address(); + static const int kIpAddressFieldNumber = 1; + inline const ::std::string& ip_address() const; + inline void set_ip_address(const ::std::string& value); + inline void set_ip_address(const char* value); + inline void set_ip_address(const char* value, size_t size); + inline ::std::string* mutable_ip_address(); + inline ::std::string* release_ip_address(); + inline void set_allocated_ip_address(::std::string* ip_address); + + // optional uint32 country = 2; + inline bool has_country() const; + inline void clear_country(); + static const int kCountryFieldNumber = 2; + inline ::google::protobuf::uint32 country() const; + inline void set_country(::google::protobuf::uint32 value); + + // optional string city = 3; + inline bool has_city() const; + inline void clear_city(); + static const int kCityFieldNumber = 3; + inline const ::std::string& city() const; + inline void set_city(const ::std::string& value); + inline void set_city(const char* value); + inline void set_city(const char* value, size_t size); + inline ::std::string* mutable_city(); + inline ::std::string* release_city(); + inline void set_allocated_city(::std::string* city); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameSessionLocation) + private: + inline void set_has_ip_address(); + inline void clear_has_ip_address(); + inline void set_has_country(); + inline void clear_has_country(); + inline void set_has_city(); + inline void clear_has_city(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* ip_address_; + ::std::string* city_; + ::google::protobuf::uint32 country_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static GameSessionLocation* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API CAIS : public ::google::protobuf::Message { + public: + CAIS(); + virtual ~CAIS(); + + CAIS(const CAIS& from); + + inline CAIS& operator=(const CAIS& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const CAIS& default_instance(); + + void Swap(CAIS* other); + + // implements Message ---------------------------------------------- + + CAIS* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const CAIS& from); + void MergeFrom(const CAIS& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint32 played_minutes = 1; + inline bool has_played_minutes() const; + inline void clear_played_minutes(); + static const int kPlayedMinutesFieldNumber = 1; + inline ::google::protobuf::uint32 played_minutes() const; + inline void set_played_minutes(::google::protobuf::uint32 value); + + // optional uint32 rested_minutes = 2; + inline bool has_rested_minutes() const; + inline void clear_rested_minutes(); + static const int kRestedMinutesFieldNumber = 2; + inline ::google::protobuf::uint32 rested_minutes() const; + inline void set_rested_minutes(::google::protobuf::uint32 value); + + // optional uint64 last_heard_time = 3; + inline bool has_last_heard_time() const; + inline void clear_last_heard_time(); + static const int kLastHeardTimeFieldNumber = 3; + inline ::google::protobuf::uint64 last_heard_time() const; + inline void set_last_heard_time(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.CAIS) + private: + inline void set_has_played_minutes(); + inline void clear_has_played_minutes(); + inline void set_has_rested_minutes(); + inline void clear_has_rested_minutes(); + inline void set_has_last_heard_time(); + inline void clear_has_last_heard_time(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 played_minutes_; + ::google::protobuf::uint32 rested_minutes_; + ::google::protobuf::uint64 last_heard_time_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static CAIS* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GameAccountList : public ::google::protobuf::Message { + public: + GameAccountList(); + virtual ~GameAccountList(); + + GameAccountList(const GameAccountList& from); + + inline GameAccountList& operator=(const GameAccountList& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GameAccountList& default_instance(); + + void Swap(GameAccountList* other); + + // implements Message ---------------------------------------------- + + GameAccountList* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GameAccountList& from); + void MergeFrom(const GameAccountList& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint32 region = 3; + inline bool has_region() const; + inline void clear_region(); + static const int kRegionFieldNumber = 3; + inline ::google::protobuf::uint32 region() const; + inline void set_region(::google::protobuf::uint32 value); + + // repeated .bgs.protocol.account.v1.GameAccountHandle handle = 4; + inline int handle_size() const; + inline void clear_handle(); + static const int kHandleFieldNumber = 4; + inline const ::bgs::protocol::account::v1::GameAccountHandle& handle(int index) const; + inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_handle(int index); + inline ::bgs::protocol::account::v1::GameAccountHandle* add_handle(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle >& + handle() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle >* + mutable_handle(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountList) + private: + inline void set_has_region(); + inline void clear_has_region(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle > handle_; + ::google::protobuf::uint32 region_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static GameAccountList* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API AccountState : public ::google::protobuf::Message { + public: + AccountState(); + virtual ~AccountState(); + + AccountState(const AccountState& from); + + inline AccountState& operator=(const AccountState& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AccountState& default_instance(); + + void Swap(AccountState* other); + + // implements Message ---------------------------------------------- + + AccountState* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AccountState& from); + void MergeFrom(const AccountState& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.account.v1.AccountLevelInfo account_level_info = 1; + inline bool has_account_level_info() const; + inline void clear_account_level_info(); + static const int kAccountLevelInfoFieldNumber = 1; + inline const ::bgs::protocol::account::v1::AccountLevelInfo& account_level_info() const; + inline ::bgs::protocol::account::v1::AccountLevelInfo* mutable_account_level_info(); + inline ::bgs::protocol::account::v1::AccountLevelInfo* release_account_level_info(); + inline void set_allocated_account_level_info(::bgs::protocol::account::v1::AccountLevelInfo* account_level_info); + + // optional .bgs.protocol.account.v1.PrivacyInfo privacy_info = 2; + inline bool has_privacy_info() const; + inline void clear_privacy_info(); + static const int kPrivacyInfoFieldNumber = 2; + inline const ::bgs::protocol::account::v1::PrivacyInfo& privacy_info() const; + inline ::bgs::protocol::account::v1::PrivacyInfo* mutable_privacy_info(); + inline ::bgs::protocol::account::v1::PrivacyInfo* release_privacy_info(); + inline void set_allocated_privacy_info(::bgs::protocol::account::v1::PrivacyInfo* privacy_info); + + // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 3; + inline bool has_parental_control_info() const; + inline void clear_parental_control_info(); + static const int kParentalControlInfoFieldNumber = 3; + inline const ::bgs::protocol::account::v1::ParentalControlInfo& parental_control_info() const; + inline ::bgs::protocol::account::v1::ParentalControlInfo* mutable_parental_control_info(); + inline ::bgs::protocol::account::v1::ParentalControlInfo* release_parental_control_info(); + inline void set_allocated_parental_control_info(::bgs::protocol::account::v1::ParentalControlInfo* parental_control_info); + + // repeated .bgs.protocol.account.v1.GameLevelInfo game_level_info = 5; + inline int game_level_info_size() const; + inline void clear_game_level_info(); + static const int kGameLevelInfoFieldNumber = 5; + inline const ::bgs::protocol::account::v1::GameLevelInfo& game_level_info(int index) const; + inline ::bgs::protocol::account::v1::GameLevelInfo* mutable_game_level_info(int index); + inline ::bgs::protocol::account::v1::GameLevelInfo* add_game_level_info(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameLevelInfo >& + game_level_info() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameLevelInfo >* + mutable_game_level_info(); + + // repeated .bgs.protocol.account.v1.GameStatus game_status = 6; + inline int game_status_size() const; + inline void clear_game_status(); + static const int kGameStatusFieldNumber = 6; + inline const ::bgs::protocol::account::v1::GameStatus& game_status(int index) const; + inline ::bgs::protocol::account::v1::GameStatus* mutable_game_status(int index); + inline ::bgs::protocol::account::v1::GameStatus* add_game_status(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameStatus >& + game_status() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameStatus >* + mutable_game_status(); + + // repeated .bgs.protocol.account.v1.GameAccountList game_accounts = 7; + inline int game_accounts_size() const; + inline void clear_game_accounts(); + static const int kGameAccountsFieldNumber = 7; + inline const ::bgs::protocol::account::v1::GameAccountList& game_accounts(int index) const; + inline ::bgs::protocol::account::v1::GameAccountList* mutable_game_accounts(int index); + inline ::bgs::protocol::account::v1::GameAccountList* add_game_accounts(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList >& + game_accounts() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList >* + mutable_game_accounts(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountState) + private: + inline void set_has_account_level_info(); + inline void clear_has_account_level_info(); + inline void set_has_privacy_info(); + inline void clear_has_privacy_info(); + inline void set_has_parental_control_info(); + inline void clear_has_parental_control_info(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::account::v1::AccountLevelInfo* account_level_info_; + ::bgs::protocol::account::v1::PrivacyInfo* privacy_info_; + ::bgs::protocol::account::v1::ParentalControlInfo* parental_control_info_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameLevelInfo > game_level_info_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameStatus > game_status_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList > game_accounts_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static AccountState* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API AccountStateTagged : public ::google::protobuf::Message { + public: + AccountStateTagged(); + virtual ~AccountStateTagged(); + + AccountStateTagged(const AccountStateTagged& from); + + inline AccountStateTagged& operator=(const AccountStateTagged& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AccountStateTagged& default_instance(); + + void Swap(AccountStateTagged* other); + + // implements Message ---------------------------------------------- + + AccountStateTagged* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AccountStateTagged& from); + void MergeFrom(const AccountStateTagged& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.account.v1.AccountState account_state = 1; + inline bool has_account_state() const; + inline void clear_account_state(); + static const int kAccountStateFieldNumber = 1; + inline const ::bgs::protocol::account::v1::AccountState& account_state() const; + inline ::bgs::protocol::account::v1::AccountState* mutable_account_state(); + inline ::bgs::protocol::account::v1::AccountState* release_account_state(); + inline void set_allocated_account_state(::bgs::protocol::account::v1::AccountState* account_state); + + // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 2; + inline bool has_account_tags() const; + inline void clear_account_tags(); + static const int kAccountTagsFieldNumber = 2; + inline const ::bgs::protocol::account::v1::AccountFieldTags& account_tags() const; + inline ::bgs::protocol::account::v1::AccountFieldTags* mutable_account_tags(); + inline ::bgs::protocol::account::v1::AccountFieldTags* release_account_tags(); + inline void set_allocated_account_tags(::bgs::protocol::account::v1::AccountFieldTags* account_tags); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountStateTagged) + private: + inline void set_has_account_state(); + inline void clear_has_account_state(); + inline void set_has_account_tags(); + inline void clear_has_account_tags(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::account::v1::AccountState* account_state_; + ::bgs::protocol::account::v1::AccountFieldTags* account_tags_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static AccountStateTagged* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GameAccountState : public ::google::protobuf::Message { + public: + GameAccountState(); + virtual ~GameAccountState(); + + GameAccountState(const GameAccountState& from); + + inline GameAccountState& operator=(const GameAccountState& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GameAccountState& default_instance(); + + void Swap(GameAccountState* other); + + // implements Message ---------------------------------------------- + + GameAccountState* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GameAccountState& from); + void MergeFrom(const GameAccountState& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.account.v1.GameLevelInfo game_level_info = 1; + inline bool has_game_level_info() const; + inline void clear_game_level_info(); + static const int kGameLevelInfoFieldNumber = 1; + inline const ::bgs::protocol::account::v1::GameLevelInfo& game_level_info() const; + inline ::bgs::protocol::account::v1::GameLevelInfo* mutable_game_level_info(); + inline ::bgs::protocol::account::v1::GameLevelInfo* release_game_level_info(); + inline void set_allocated_game_level_info(::bgs::protocol::account::v1::GameLevelInfo* game_level_info); + + // optional .bgs.protocol.account.v1.GameTimeInfo game_time_info = 2; + inline bool has_game_time_info() const; + inline void clear_game_time_info(); + static const int kGameTimeInfoFieldNumber = 2; + inline const ::bgs::protocol::account::v1::GameTimeInfo& game_time_info() const; + inline ::bgs::protocol::account::v1::GameTimeInfo* mutable_game_time_info(); + inline ::bgs::protocol::account::v1::GameTimeInfo* release_game_time_info(); + inline void set_allocated_game_time_info(::bgs::protocol::account::v1::GameTimeInfo* game_time_info); + + // optional .bgs.protocol.account.v1.GameStatus game_status = 3; + inline bool has_game_status() const; + inline void clear_game_status(); + static const int kGameStatusFieldNumber = 3; + inline const ::bgs::protocol::account::v1::GameStatus& game_status() const; + inline ::bgs::protocol::account::v1::GameStatus* mutable_game_status(); + inline ::bgs::protocol::account::v1::GameStatus* release_game_status(); + inline void set_allocated_game_status(::bgs::protocol::account::v1::GameStatus* game_status); + + // optional .bgs.protocol.account.v1.RAFInfo raf_info = 4; + inline bool has_raf_info() const; + inline void clear_raf_info(); + static const int kRafInfoFieldNumber = 4; + inline const ::bgs::protocol::account::v1::RAFInfo& raf_info() const; + inline ::bgs::protocol::account::v1::RAFInfo* mutable_raf_info(); + inline ::bgs::protocol::account::v1::RAFInfo* release_raf_info(); + inline void set_allocated_raf_info(::bgs::protocol::account::v1::RAFInfo* raf_info); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountState) + private: + inline void set_has_game_level_info(); + inline void clear_has_game_level_info(); + inline void set_has_game_time_info(); + inline void clear_has_game_time_info(); + inline void set_has_game_status(); + inline void clear_has_game_status(); + inline void set_has_raf_info(); + inline void clear_has_raf_info(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::account::v1::GameLevelInfo* game_level_info_; + ::bgs::protocol::account::v1::GameTimeInfo* game_time_info_; + ::bgs::protocol::account::v1::GameStatus* game_status_; + ::bgs::protocol::account::v1::RAFInfo* raf_info_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static GameAccountState* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GameAccountStateTagged : public ::google::protobuf::Message { + public: + GameAccountStateTagged(); + virtual ~GameAccountStateTagged(); + + GameAccountStateTagged(const GameAccountStateTagged& from); + + inline GameAccountStateTagged& operator=(const GameAccountStateTagged& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GameAccountStateTagged& default_instance(); + + void Swap(GameAccountStateTagged* other); + + // implements Message ---------------------------------------------- + + GameAccountStateTagged* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GameAccountStateTagged& from); + void MergeFrom(const GameAccountStateTagged& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.account.v1.GameAccountState game_account_state = 1; + inline bool has_game_account_state() const; + inline void clear_game_account_state(); + static const int kGameAccountStateFieldNumber = 1; + inline const ::bgs::protocol::account::v1::GameAccountState& game_account_state() const; + inline ::bgs::protocol::account::v1::GameAccountState* mutable_game_account_state(); + inline ::bgs::protocol::account::v1::GameAccountState* release_game_account_state(); + inline void set_allocated_game_account_state(::bgs::protocol::account::v1::GameAccountState* game_account_state); + + // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 2; + inline bool has_game_account_tags() const; + inline void clear_game_account_tags(); + static const int kGameAccountTagsFieldNumber = 2; + inline const ::bgs::protocol::account::v1::GameAccountFieldTags& game_account_tags() const; + inline ::bgs::protocol::account::v1::GameAccountFieldTags* mutable_game_account_tags(); + inline ::bgs::protocol::account::v1::GameAccountFieldTags* release_game_account_tags(); + inline void set_allocated_game_account_tags(::bgs::protocol::account::v1::GameAccountFieldTags* game_account_tags); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountStateTagged) + private: + inline void set_has_game_account_state(); + inline void clear_has_game_account_state(); + inline void set_has_game_account_tags(); + inline void clear_has_game_account_tags(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::account::v1::GameAccountState* game_account_state_; + ::bgs::protocol::account::v1::GameAccountFieldTags* game_account_tags_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static GameAccountStateTagged* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API AuthorizedData : public ::google::protobuf::Message { + public: + AuthorizedData(); + virtual ~AuthorizedData(); + + AuthorizedData(const AuthorizedData& from); + + inline AuthorizedData& operator=(const AuthorizedData& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AuthorizedData& default_instance(); + + void Swap(AuthorizedData* other); + + // implements Message ---------------------------------------------- + + AuthorizedData* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AuthorizedData& from); + void MergeFrom(const AuthorizedData& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string data = 1; + inline bool has_data() const; + inline void clear_data(); + static const int kDataFieldNumber = 1; + inline const ::std::string& data() const; + inline void set_data(const ::std::string& value); + inline void set_data(const char* value); + inline void set_data(const char* value, size_t size); + inline ::std::string* mutable_data(); + inline ::std::string* release_data(); + inline void set_allocated_data(::std::string* data); + + // repeated uint32 license = 2; + inline int license_size() const; + inline void clear_license(); + static const int kLicenseFieldNumber = 2; + inline ::google::protobuf::uint32 license(int index) const; + inline void set_license(int index, ::google::protobuf::uint32 value); + inline void add_license(::google::protobuf::uint32 value); + inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + license() const; + inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_license(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AuthorizedData) + private: + inline void set_has_data(); + inline void clear_has_data(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* data_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > license_; + friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto(); + friend void protobuf_AssignDesc_account_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_account_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static AuthorizedData* default_instance_; +}; +// =================================================================== + + +// =================================================================== + + +// =================================================================== + +// AccountId + +// required fixed32 id = 1; +inline bool AccountId::has_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AccountId::set_has_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void AccountId::clear_has_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AccountId::clear_id() { + id_ = 0u; + clear_has_id(); +} +inline ::google::protobuf::uint32 AccountId::id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountId.id) + return id_; +} +inline void AccountId::set_id(::google::protobuf::uint32 value) { + set_has_id(); + id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountId.id) +} + +// ------------------------------------------------------------------- + +// AccountLicense + +// required uint32 id = 1; +inline bool AccountLicense::has_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AccountLicense::set_has_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void AccountLicense::clear_has_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AccountLicense::clear_id() { + id_ = 0u; + clear_has_id(); +} +inline ::google::protobuf::uint32 AccountLicense::id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLicense.id) + return id_; +} +inline void AccountLicense::set_id(::google::protobuf::uint32 value) { + set_has_id(); + id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLicense.id) +} + +// optional uint64 expires = 2; +inline bool AccountLicense::has_expires() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void AccountLicense::set_has_expires() { + _has_bits_[0] |= 0x00000002u; +} +inline void AccountLicense::clear_has_expires() { + _has_bits_[0] &= ~0x00000002u; +} +inline void AccountLicense::clear_expires() { + expires_ = GOOGLE_ULONGLONG(0); + clear_has_expires(); +} +inline ::google::protobuf::uint64 AccountLicense::expires() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLicense.expires) + return expires_; +} +inline void AccountLicense::set_expires(::google::protobuf::uint64 value) { + set_has_expires(); + expires_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLicense.expires) +} + +// ------------------------------------------------------------------- + +// AccountCredential + +// required uint32 id = 1; +inline bool AccountCredential::has_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AccountCredential::set_has_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void AccountCredential::clear_has_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AccountCredential::clear_id() { + id_ = 0u; + clear_has_id(); +} +inline ::google::protobuf::uint32 AccountCredential::id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountCredential.id) + return id_; +} +inline void AccountCredential::set_id(::google::protobuf::uint32 value) { + set_has_id(); + id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountCredential.id) +} + +// optional bytes data = 2; +inline bool AccountCredential::has_data() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void AccountCredential::set_has_data() { + _has_bits_[0] |= 0x00000002u; +} +inline void AccountCredential::clear_has_data() { + _has_bits_[0] &= ~0x00000002u; +} +inline void AccountCredential::clear_data() { + if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_->clear(); + } + clear_has_data(); +} +inline const ::std::string& AccountCredential::data() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountCredential.data) + return *data_; +} +inline void AccountCredential::set_data(const ::std::string& value) { + set_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_ = new ::std::string; + } + data_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountCredential.data) +} +inline void AccountCredential::set_data(const char* value) { + set_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_ = new ::std::string; + } + data_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountCredential.data) +} +inline void AccountCredential::set_data(const void* value, size_t size) { + set_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_ = new ::std::string; + } + data_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountCredential.data) +} +inline ::std::string* AccountCredential::mutable_data() { + set_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountCredential.data) + return data_; +} +inline ::std::string* AccountCredential::release_data() { + clear_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = data_; + data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void AccountCredential::set_allocated_data(::std::string* data) { + if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete data_; + } + if (data) { + set_has_data(); + data_ = data; + } else { + clear_has_data(); + data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountCredential.data) +} + +// ------------------------------------------------------------------- + +// AccountBlob + +// required fixed32 id = 2; +inline bool AccountBlob::has_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AccountBlob::set_has_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void AccountBlob::clear_has_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AccountBlob::clear_id() { + id_ = 0u; + clear_has_id(); +} +inline ::google::protobuf::uint32 AccountBlob::id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.id) + return id_; +} +inline void AccountBlob::set_id(::google::protobuf::uint32 value) { + set_has_id(); + id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.id) +} + +// required uint32 region = 3; +inline bool AccountBlob::has_region() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void AccountBlob::set_has_region() { + _has_bits_[0] |= 0x00000002u; +} +inline void AccountBlob::clear_has_region() { + _has_bits_[0] &= ~0x00000002u; +} +inline void AccountBlob::clear_region() { + region_ = 0u; + clear_has_region(); +} +inline ::google::protobuf::uint32 AccountBlob::region() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.region) + return region_; +} +inline void AccountBlob::set_region(::google::protobuf::uint32 value) { + set_has_region(); + region_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.region) +} + +// repeated string email = 4; +inline int AccountBlob::email_size() const { + return email_.size(); +} +inline void AccountBlob::clear_email() { + email_.Clear(); +} +inline const ::std::string& AccountBlob::email(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.email) + return email_.Get(index); +} +inline ::std::string* AccountBlob::mutable_email(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlob.email) + return email_.Mutable(index); +} +inline void AccountBlob::set_email(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.email) + email_.Mutable(index)->assign(value); +} +inline void AccountBlob::set_email(int index, const char* value) { + email_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountBlob.email) +} +inline void AccountBlob::set_email(int index, const char* value, size_t size) { + email_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountBlob.email) +} +inline ::std::string* AccountBlob::add_email() { + return email_.Add(); +} +inline void AccountBlob::add_email(const ::std::string& value) { + email_.Add()->assign(value); + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountBlob.email) +} +inline void AccountBlob::add_email(const char* value) { + email_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:bgs.protocol.account.v1.AccountBlob.email) +} +inline void AccountBlob::add_email(const char* value, size_t size) { + email_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:bgs.protocol.account.v1.AccountBlob.email) +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +AccountBlob::email() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountBlob.email) + return email_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +AccountBlob::mutable_email() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountBlob.email) + return &email_; +} + +// required uint64 flags = 5; +inline bool AccountBlob::has_flags() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void AccountBlob::set_has_flags() { + _has_bits_[0] |= 0x00000008u; +} +inline void AccountBlob::clear_has_flags() { + _has_bits_[0] &= ~0x00000008u; +} +inline void AccountBlob::clear_flags() { + flags_ = GOOGLE_ULONGLONG(0); + clear_has_flags(); +} +inline ::google::protobuf::uint64 AccountBlob::flags() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.flags) + return flags_; +} +inline void AccountBlob::set_flags(::google::protobuf::uint64 value) { + set_has_flags(); + flags_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.flags) +} + +// optional uint64 secure_release = 6; +inline bool AccountBlob::has_secure_release() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void AccountBlob::set_has_secure_release() { + _has_bits_[0] |= 0x00000010u; +} +inline void AccountBlob::clear_has_secure_release() { + _has_bits_[0] &= ~0x00000010u; +} +inline void AccountBlob::clear_secure_release() { + secure_release_ = GOOGLE_ULONGLONG(0); + clear_has_secure_release(); +} +inline ::google::protobuf::uint64 AccountBlob::secure_release() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.secure_release) + return secure_release_; +} +inline void AccountBlob::set_secure_release(::google::protobuf::uint64 value) { + set_has_secure_release(); + secure_release_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.secure_release) +} + +// optional uint64 whitelist_start = 7; +inline bool AccountBlob::has_whitelist_start() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void AccountBlob::set_has_whitelist_start() { + _has_bits_[0] |= 0x00000020u; +} +inline void AccountBlob::clear_has_whitelist_start() { + _has_bits_[0] &= ~0x00000020u; +} +inline void AccountBlob::clear_whitelist_start() { + whitelist_start_ = GOOGLE_ULONGLONG(0); + clear_has_whitelist_start(); +} +inline ::google::protobuf::uint64 AccountBlob::whitelist_start() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.whitelist_start) + return whitelist_start_; +} +inline void AccountBlob::set_whitelist_start(::google::protobuf::uint64 value) { + set_has_whitelist_start(); + whitelist_start_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.whitelist_start) +} + +// optional uint64 whitelist_end = 8; +inline bool AccountBlob::has_whitelist_end() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void AccountBlob::set_has_whitelist_end() { + _has_bits_[0] |= 0x00000040u; +} +inline void AccountBlob::clear_has_whitelist_end() { + _has_bits_[0] &= ~0x00000040u; +} +inline void AccountBlob::clear_whitelist_end() { + whitelist_end_ = GOOGLE_ULONGLONG(0); + clear_has_whitelist_end(); +} +inline ::google::protobuf::uint64 AccountBlob::whitelist_end() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.whitelist_end) + return whitelist_end_; +} +inline void AccountBlob::set_whitelist_end(::google::protobuf::uint64 value) { + set_has_whitelist_end(); + whitelist_end_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.whitelist_end) +} + +// required string full_name = 10; +inline bool AccountBlob::has_full_name() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void AccountBlob::set_has_full_name() { + _has_bits_[0] |= 0x00000080u; +} +inline void AccountBlob::clear_has_full_name() { + _has_bits_[0] &= ~0x00000080u; +} +inline void AccountBlob::clear_full_name() { + if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + full_name_->clear(); + } + clear_has_full_name(); +} +inline const ::std::string& AccountBlob::full_name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.full_name) + return *full_name_; +} +inline void AccountBlob::set_full_name(const ::std::string& value) { + set_has_full_name(); + if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + full_name_ = new ::std::string; + } + full_name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.full_name) +} +inline void AccountBlob::set_full_name(const char* value) { + set_has_full_name(); + if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + full_name_ = new ::std::string; + } + full_name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountBlob.full_name) +} +inline void AccountBlob::set_full_name(const char* value, size_t size) { + set_has_full_name(); + if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + full_name_ = new ::std::string; + } + full_name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountBlob.full_name) +} +inline ::std::string* AccountBlob::mutable_full_name() { + set_has_full_name(); + if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + full_name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlob.full_name) + return full_name_; +} +inline ::std::string* AccountBlob::release_full_name() { + clear_has_full_name(); + if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = full_name_; + full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void AccountBlob::set_allocated_full_name(::std::string* full_name) { + if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete full_name_; + } + if (full_name) { + set_has_full_name(); + full_name_ = full_name; + } else { + clear_has_full_name(); + full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountBlob.full_name) +} + +// repeated .bgs.protocol.account.v1.AccountLicense licenses = 20; +inline int AccountBlob::licenses_size() const { + return licenses_.size(); +} +inline void AccountBlob::clear_licenses() { + licenses_.Clear(); +} +inline const ::bgs::protocol::account::v1::AccountLicense& AccountBlob::licenses(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.licenses) + return licenses_.Get(index); +} +inline ::bgs::protocol::account::v1::AccountLicense* AccountBlob::mutable_licenses(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlob.licenses) + return licenses_.Mutable(index); +} +inline ::bgs::protocol::account::v1::AccountLicense* AccountBlob::add_licenses() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountBlob.licenses) + return licenses_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >& +AccountBlob::licenses() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountBlob.licenses) + return licenses_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >* +AccountBlob::mutable_licenses() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountBlob.licenses) + return &licenses_; +} + +// repeated .bgs.protocol.account.v1.AccountCredential credentials = 21; +inline int AccountBlob::credentials_size() const { + return credentials_.size(); +} +inline void AccountBlob::clear_credentials() { + credentials_.Clear(); +} +inline const ::bgs::protocol::account::v1::AccountCredential& AccountBlob::credentials(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.credentials) + return credentials_.Get(index); +} +inline ::bgs::protocol::account::v1::AccountCredential* AccountBlob::mutable_credentials(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlob.credentials) + return credentials_.Mutable(index); +} +inline ::bgs::protocol::account::v1::AccountCredential* AccountBlob::add_credentials() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountBlob.credentials) + return credentials_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >& +AccountBlob::credentials() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountBlob.credentials) + return credentials_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >* +AccountBlob::mutable_credentials() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountBlob.credentials) + return &credentials_; +} + +// repeated .bgs.protocol.account.v1.GameAccountLink account_links = 22; +inline int AccountBlob::account_links_size() const { + return account_links_.size(); +} +inline void AccountBlob::clear_account_links() { + account_links_.Clear(); +} +inline const ::bgs::protocol::account::v1::GameAccountLink& AccountBlob::account_links(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.account_links) + return account_links_.Get(index); +} +inline ::bgs::protocol::account::v1::GameAccountLink* AccountBlob::mutable_account_links(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlob.account_links) + return account_links_.Mutable(index); +} +inline ::bgs::protocol::account::v1::GameAccountLink* AccountBlob::add_account_links() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountBlob.account_links) + return account_links_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink >& +AccountBlob::account_links() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountBlob.account_links) + return account_links_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink >* +AccountBlob::mutable_account_links() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountBlob.account_links) + return &account_links_; +} + +// optional string battle_tag = 23; +inline bool AccountBlob::has_battle_tag() const { + return (_has_bits_[0] & 0x00000800u) != 0; +} +inline void AccountBlob::set_has_battle_tag() { + _has_bits_[0] |= 0x00000800u; +} +inline void AccountBlob::clear_has_battle_tag() { + _has_bits_[0] &= ~0x00000800u; +} +inline void AccountBlob::clear_battle_tag() { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_->clear(); + } + clear_has_battle_tag(); +} +inline const ::std::string& AccountBlob::battle_tag() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.battle_tag) + return *battle_tag_; +} +inline void AccountBlob::set_battle_tag(const ::std::string& value) { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + battle_tag_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.battle_tag) +} +inline void AccountBlob::set_battle_tag(const char* value) { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + battle_tag_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountBlob.battle_tag) +} +inline void AccountBlob::set_battle_tag(const char* value, size_t size) { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + battle_tag_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountBlob.battle_tag) +} +inline ::std::string* AccountBlob::mutable_battle_tag() { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlob.battle_tag) + return battle_tag_; +} +inline ::std::string* AccountBlob::release_battle_tag() { + clear_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = battle_tag_; + battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void AccountBlob::set_allocated_battle_tag(::std::string* battle_tag) { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete battle_tag_; + } + if (battle_tag) { + set_has_battle_tag(); + battle_tag_ = battle_tag; + } else { + clear_has_battle_tag(); + battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountBlob.battle_tag) +} + +// optional fixed32 default_currency = 25; +inline bool AccountBlob::has_default_currency() const { + return (_has_bits_[0] & 0x00001000u) != 0; +} +inline void AccountBlob::set_has_default_currency() { + _has_bits_[0] |= 0x00001000u; +} +inline void AccountBlob::clear_has_default_currency() { + _has_bits_[0] &= ~0x00001000u; +} +inline void AccountBlob::clear_default_currency() { + default_currency_ = 0u; + clear_has_default_currency(); +} +inline ::google::protobuf::uint32 AccountBlob::default_currency() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.default_currency) + return default_currency_; +} +inline void AccountBlob::set_default_currency(::google::protobuf::uint32 value) { + set_has_default_currency(); + default_currency_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.default_currency) +} + +// optional uint32 legal_region = 26; +inline bool AccountBlob::has_legal_region() const { + return (_has_bits_[0] & 0x00002000u) != 0; +} +inline void AccountBlob::set_has_legal_region() { + _has_bits_[0] |= 0x00002000u; +} +inline void AccountBlob::clear_has_legal_region() { + _has_bits_[0] &= ~0x00002000u; +} +inline void AccountBlob::clear_legal_region() { + legal_region_ = 0u; + clear_has_legal_region(); +} +inline ::google::protobuf::uint32 AccountBlob::legal_region() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.legal_region) + return legal_region_; +} +inline void AccountBlob::set_legal_region(::google::protobuf::uint32 value) { + set_has_legal_region(); + legal_region_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.legal_region) +} + +// optional fixed32 legal_locale = 27; +inline bool AccountBlob::has_legal_locale() const { + return (_has_bits_[0] & 0x00004000u) != 0; +} +inline void AccountBlob::set_has_legal_locale() { + _has_bits_[0] |= 0x00004000u; +} +inline void AccountBlob::clear_has_legal_locale() { + _has_bits_[0] &= ~0x00004000u; +} +inline void AccountBlob::clear_legal_locale() { + legal_locale_ = 0u; + clear_has_legal_locale(); +} +inline ::google::protobuf::uint32 AccountBlob::legal_locale() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.legal_locale) + return legal_locale_; +} +inline void AccountBlob::set_legal_locale(::google::protobuf::uint32 value) { + set_has_legal_locale(); + legal_locale_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.legal_locale) +} + +// required uint64 cache_expiration = 30; +inline bool AccountBlob::has_cache_expiration() const { + return (_has_bits_[0] & 0x00008000u) != 0; +} +inline void AccountBlob::set_has_cache_expiration() { + _has_bits_[0] |= 0x00008000u; +} +inline void AccountBlob::clear_has_cache_expiration() { + _has_bits_[0] &= ~0x00008000u; +} +inline void AccountBlob::clear_cache_expiration() { + cache_expiration_ = GOOGLE_ULONGLONG(0); + clear_has_cache_expiration(); +} +inline ::google::protobuf::uint64 AccountBlob::cache_expiration() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.cache_expiration) + return cache_expiration_; +} +inline void AccountBlob::set_cache_expiration(::google::protobuf::uint64 value) { + set_has_cache_expiration(); + cache_expiration_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.cache_expiration) +} + +// optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 31; +inline bool AccountBlob::has_parental_control_info() const { + return (_has_bits_[0] & 0x00010000u) != 0; +} +inline void AccountBlob::set_has_parental_control_info() { + _has_bits_[0] |= 0x00010000u; +} +inline void AccountBlob::clear_has_parental_control_info() { + _has_bits_[0] &= ~0x00010000u; +} +inline void AccountBlob::clear_parental_control_info() { + if (parental_control_info_ != NULL) parental_control_info_->::bgs::protocol::account::v1::ParentalControlInfo::Clear(); + clear_has_parental_control_info(); +} +inline const ::bgs::protocol::account::v1::ParentalControlInfo& AccountBlob::parental_control_info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.parental_control_info) + return parental_control_info_ != NULL ? *parental_control_info_ : *default_instance_->parental_control_info_; +} +inline ::bgs::protocol::account::v1::ParentalControlInfo* AccountBlob::mutable_parental_control_info() { + set_has_parental_control_info(); + if (parental_control_info_ == NULL) parental_control_info_ = new ::bgs::protocol::account::v1::ParentalControlInfo; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlob.parental_control_info) + return parental_control_info_; +} +inline ::bgs::protocol::account::v1::ParentalControlInfo* AccountBlob::release_parental_control_info() { + clear_has_parental_control_info(); + ::bgs::protocol::account::v1::ParentalControlInfo* temp = parental_control_info_; + parental_control_info_ = NULL; + return temp; +} +inline void AccountBlob::set_allocated_parental_control_info(::bgs::protocol::account::v1::ParentalControlInfo* parental_control_info) { + delete parental_control_info_; + parental_control_info_ = parental_control_info; + if (parental_control_info) { + set_has_parental_control_info(); + } else { + clear_has_parental_control_info(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountBlob.parental_control_info) +} + +// optional string country = 32; +inline bool AccountBlob::has_country() const { + return (_has_bits_[0] & 0x00020000u) != 0; +} +inline void AccountBlob::set_has_country() { + _has_bits_[0] |= 0x00020000u; +} +inline void AccountBlob::clear_has_country() { + _has_bits_[0] &= ~0x00020000u; +} +inline void AccountBlob::clear_country() { + if (country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + country_->clear(); + } + clear_has_country(); +} +inline const ::std::string& AccountBlob::country() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.country) + return *country_; +} +inline void AccountBlob::set_country(const ::std::string& value) { + set_has_country(); + if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + country_ = new ::std::string; + } + country_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.country) +} +inline void AccountBlob::set_country(const char* value) { + set_has_country(); + if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + country_ = new ::std::string; + } + country_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountBlob.country) +} +inline void AccountBlob::set_country(const char* value, size_t size) { + set_has_country(); + if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + country_ = new ::std::string; + } + country_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountBlob.country) +} +inline ::std::string* AccountBlob::mutable_country() { + set_has_country(); + if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + country_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlob.country) + return country_; +} +inline ::std::string* AccountBlob::release_country() { + clear_has_country(); + if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = country_; + country_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void AccountBlob::set_allocated_country(::std::string* country) { + if (country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete country_; + } + if (country) { + set_has_country(); + country_ = country; + } else { + clear_has_country(); + country_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountBlob.country) +} + +// optional uint32 preferred_region = 33; +inline bool AccountBlob::has_preferred_region() const { + return (_has_bits_[0] & 0x00040000u) != 0; +} +inline void AccountBlob::set_has_preferred_region() { + _has_bits_[0] |= 0x00040000u; +} +inline void AccountBlob::clear_has_preferred_region() { + _has_bits_[0] &= ~0x00040000u; +} +inline void AccountBlob::clear_preferred_region() { + preferred_region_ = 0u; + clear_has_preferred_region(); +} +inline ::google::protobuf::uint32 AccountBlob::preferred_region() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.preferred_region) + return preferred_region_; +} +inline void AccountBlob::set_preferred_region(::google::protobuf::uint32 value) { + set_has_preferred_region(); + preferred_region_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.preferred_region) +} + +// optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 34; +inline bool AccountBlob::has_identity_check_status() const { + return (_has_bits_[0] & 0x00080000u) != 0; +} +inline void AccountBlob::set_has_identity_check_status() { + _has_bits_[0] |= 0x00080000u; +} +inline void AccountBlob::clear_has_identity_check_status() { + _has_bits_[0] &= ~0x00080000u; +} +inline void AccountBlob::clear_identity_check_status() { + identity_check_status_ = 0; + clear_has_identity_check_status(); +} +inline ::bgs::protocol::account::v1::IdentityVerificationStatus AccountBlob::identity_check_status() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.identity_check_status) + return static_cast< ::bgs::protocol::account::v1::IdentityVerificationStatus >(identity_check_status_); +} +inline void AccountBlob::set_identity_check_status(::bgs::protocol::account::v1::IdentityVerificationStatus value) { + assert(::bgs::protocol::account::v1::IdentityVerificationStatus_IsValid(value)); + set_has_identity_check_status(); + identity_check_status_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.identity_check_status) +} + +// ------------------------------------------------------------------- + +// AccountBlobList + +// repeated .bgs.protocol.account.v1.AccountBlob blob = 1; +inline int AccountBlobList::blob_size() const { + return blob_.size(); +} +inline void AccountBlobList::clear_blob() { + blob_.Clear(); +} +inline const ::bgs::protocol::account::v1::AccountBlob& AccountBlobList::blob(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlobList.blob) + return blob_.Get(index); +} +inline ::bgs::protocol::account::v1::AccountBlob* AccountBlobList::mutable_blob(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlobList.blob) + return blob_.Mutable(index); +} +inline ::bgs::protocol::account::v1::AccountBlob* AccountBlobList::add_blob() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountBlobList.blob) + return blob_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountBlob >& +AccountBlobList::blob() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountBlobList.blob) + return blob_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountBlob >* +AccountBlobList::mutable_blob() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountBlobList.blob) + return &blob_; +} + +// ------------------------------------------------------------------- + +// GameAccountHandle + +// required fixed32 id = 1; +inline bool GameAccountHandle::has_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GameAccountHandle::set_has_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void GameAccountHandle::clear_has_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GameAccountHandle::clear_id() { + id_ = 0u; + clear_has_id(); +} +inline ::google::protobuf::uint32 GameAccountHandle::id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountHandle.id) + return id_; +} +inline void GameAccountHandle::set_id(::google::protobuf::uint32 value) { + set_has_id(); + id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountHandle.id) +} + +// required fixed32 program = 2; +inline bool GameAccountHandle::has_program() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GameAccountHandle::set_has_program() { + _has_bits_[0] |= 0x00000002u; +} +inline void GameAccountHandle::clear_has_program() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GameAccountHandle::clear_program() { + program_ = 0u; + clear_has_program(); +} +inline ::google::protobuf::uint32 GameAccountHandle::program() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountHandle.program) + return program_; +} +inline void GameAccountHandle::set_program(::google::protobuf::uint32 value) { + set_has_program(); + program_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountHandle.program) +} + +// required uint32 region = 3; +inline bool GameAccountHandle::has_region() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GameAccountHandle::set_has_region() { + _has_bits_[0] |= 0x00000004u; +} +inline void GameAccountHandle::clear_has_region() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GameAccountHandle::clear_region() { + region_ = 0u; + clear_has_region(); +} +inline ::google::protobuf::uint32 GameAccountHandle::region() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountHandle.region) + return region_; +} +inline void GameAccountHandle::set_region(::google::protobuf::uint32 value) { + set_has_region(); + region_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountHandle.region) +} + +// ------------------------------------------------------------------- + +// GameAccountLink + +// required .bgs.protocol.account.v1.GameAccountHandle game_account = 1; +inline bool GameAccountLink::has_game_account() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GameAccountLink::set_has_game_account() { + _has_bits_[0] |= 0x00000001u; +} +inline void GameAccountLink::clear_has_game_account() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GameAccountLink::clear_game_account() { + if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear(); + clear_has_game_account(); +} +inline const ::bgs::protocol::account::v1::GameAccountHandle& GameAccountLink::game_account() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountLink.game_account) + return game_account_ != NULL ? *game_account_ : *default_instance_->game_account_; +} +inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountLink::mutable_game_account() { + set_has_game_account(); + if (game_account_ == NULL) game_account_ = new ::bgs::protocol::account::v1::GameAccountHandle; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountLink.game_account) + return game_account_; +} +inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountLink::release_game_account() { + clear_has_game_account(); + ::bgs::protocol::account::v1::GameAccountHandle* temp = game_account_; + game_account_ = NULL; + return temp; +} +inline void GameAccountLink::set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account) { + delete game_account_; + game_account_ = game_account; + if (game_account) { + set_has_game_account(); + } else { + clear_has_game_account(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountLink.game_account) +} + +// required string name = 2; +inline bool GameAccountLink::has_name() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GameAccountLink::set_has_name() { + _has_bits_[0] |= 0x00000002u; +} +inline void GameAccountLink::clear_has_name() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GameAccountLink::clear_name() { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& GameAccountLink::name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountLink.name) + return *name_; +} +inline void GameAccountLink::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountLink.name) +} +inline void GameAccountLink::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GameAccountLink.name) +} +inline void GameAccountLink::set_name(const char* value, size_t size) { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GameAccountLink.name) +} +inline ::std::string* GameAccountLink::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountLink.name) + return name_; +} +inline ::std::string* GameAccountLink::release_name() { + clear_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = name_; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void GameAccountLink::set_allocated_name(::std::string* name) { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete name_; + } + if (name) { + set_has_name(); + name_ = name; + } else { + clear_has_name(); + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountLink.name) +} + +// ------------------------------------------------------------------- + +// GameAccountBlob + +// required .bgs.protocol.account.v1.GameAccountHandle game_account = 1; +inline bool GameAccountBlob::has_game_account() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GameAccountBlob::set_has_game_account() { + _has_bits_[0] |= 0x00000001u; +} +inline void GameAccountBlob::clear_has_game_account() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GameAccountBlob::clear_game_account() { + if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear(); + clear_has_game_account(); +} +inline const ::bgs::protocol::account::v1::GameAccountHandle& GameAccountBlob::game_account() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.game_account) + return game_account_ != NULL ? *game_account_ : *default_instance_->game_account_; +} +inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountBlob::mutable_game_account() { + set_has_game_account(); + if (game_account_ == NULL) game_account_ = new ::bgs::protocol::account::v1::GameAccountHandle; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountBlob.game_account) + return game_account_; +} +inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountBlob::release_game_account() { + clear_has_game_account(); + ::bgs::protocol::account::v1::GameAccountHandle* temp = game_account_; + game_account_ = NULL; + return temp; +} +inline void GameAccountBlob::set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account) { + delete game_account_; + game_account_ = game_account; + if (game_account) { + set_has_game_account(); + } else { + clear_has_game_account(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountBlob.game_account) +} + +// optional string name = 2 [default = ""]; +inline bool GameAccountBlob::has_name() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GameAccountBlob::set_has_name() { + _has_bits_[0] |= 0x00000002u; +} +inline void GameAccountBlob::clear_has_name() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GameAccountBlob::clear_name() { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& GameAccountBlob::name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.name) + return *name_; +} +inline void GameAccountBlob::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.name) +} +inline void GameAccountBlob::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GameAccountBlob.name) +} +inline void GameAccountBlob::set_name(const char* value, size_t size) { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GameAccountBlob.name) +} +inline ::std::string* GameAccountBlob::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountBlob.name) + return name_; +} +inline ::std::string* GameAccountBlob::release_name() { + clear_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = name_; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void GameAccountBlob::set_allocated_name(::std::string* name) { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete name_; + } + if (name) { + set_has_name(); + name_ = name; + } else { + clear_has_name(); + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountBlob.name) +} + +// optional uint32 realm_permissions = 3 [default = 0]; +inline bool GameAccountBlob::has_realm_permissions() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GameAccountBlob::set_has_realm_permissions() { + _has_bits_[0] |= 0x00000004u; +} +inline void GameAccountBlob::clear_has_realm_permissions() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GameAccountBlob::clear_realm_permissions() { + realm_permissions_ = 0u; + clear_has_realm_permissions(); +} +inline ::google::protobuf::uint32 GameAccountBlob::realm_permissions() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.realm_permissions) + return realm_permissions_; +} +inline void GameAccountBlob::set_realm_permissions(::google::protobuf::uint32 value) { + set_has_realm_permissions(); + realm_permissions_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.realm_permissions) +} + +// required uint32 status = 4; +inline bool GameAccountBlob::has_status() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void GameAccountBlob::set_has_status() { + _has_bits_[0] |= 0x00000008u; +} +inline void GameAccountBlob::clear_has_status() { + _has_bits_[0] &= ~0x00000008u; +} +inline void GameAccountBlob::clear_status() { + status_ = 0u; + clear_has_status(); +} +inline ::google::protobuf::uint32 GameAccountBlob::status() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.status) + return status_; +} +inline void GameAccountBlob::set_status(::google::protobuf::uint32 value) { + set_has_status(); + status_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.status) +} + +// optional uint64 flags = 5 [default = 0]; +inline bool GameAccountBlob::has_flags() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void GameAccountBlob::set_has_flags() { + _has_bits_[0] |= 0x00000010u; +} +inline void GameAccountBlob::clear_has_flags() { + _has_bits_[0] &= ~0x00000010u; +} +inline void GameAccountBlob::clear_flags() { + flags_ = GOOGLE_ULONGLONG(0); + clear_has_flags(); +} +inline ::google::protobuf::uint64 GameAccountBlob::flags() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.flags) + return flags_; +} +inline void GameAccountBlob::set_flags(::google::protobuf::uint64 value) { + set_has_flags(); + flags_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.flags) +} + +// optional uint32 billing_flags = 6 [default = 0]; +inline bool GameAccountBlob::has_billing_flags() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void GameAccountBlob::set_has_billing_flags() { + _has_bits_[0] |= 0x00000020u; +} +inline void GameAccountBlob::clear_has_billing_flags() { + _has_bits_[0] &= ~0x00000020u; +} +inline void GameAccountBlob::clear_billing_flags() { + billing_flags_ = 0u; + clear_has_billing_flags(); +} +inline ::google::protobuf::uint32 GameAccountBlob::billing_flags() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.billing_flags) + return billing_flags_; +} +inline void GameAccountBlob::set_billing_flags(::google::protobuf::uint32 value) { + set_has_billing_flags(); + billing_flags_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.billing_flags) +} + +// required uint64 cache_expiration = 7; +inline bool GameAccountBlob::has_cache_expiration() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void GameAccountBlob::set_has_cache_expiration() { + _has_bits_[0] |= 0x00000040u; +} +inline void GameAccountBlob::clear_has_cache_expiration() { + _has_bits_[0] &= ~0x00000040u; +} +inline void GameAccountBlob::clear_cache_expiration() { + cache_expiration_ = GOOGLE_ULONGLONG(0); + clear_has_cache_expiration(); +} +inline ::google::protobuf::uint64 GameAccountBlob::cache_expiration() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.cache_expiration) + return cache_expiration_; +} +inline void GameAccountBlob::set_cache_expiration(::google::protobuf::uint64 value) { + set_has_cache_expiration(); + cache_expiration_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.cache_expiration) +} + +// optional uint64 subscription_expiration = 10; +inline bool GameAccountBlob::has_subscription_expiration() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void GameAccountBlob::set_has_subscription_expiration() { + _has_bits_[0] |= 0x00000080u; +} +inline void GameAccountBlob::clear_has_subscription_expiration() { + _has_bits_[0] &= ~0x00000080u; +} +inline void GameAccountBlob::clear_subscription_expiration() { + subscription_expiration_ = GOOGLE_ULONGLONG(0); + clear_has_subscription_expiration(); +} +inline ::google::protobuf::uint64 GameAccountBlob::subscription_expiration() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.subscription_expiration) + return subscription_expiration_; +} +inline void GameAccountBlob::set_subscription_expiration(::google::protobuf::uint64 value) { + set_has_subscription_expiration(); + subscription_expiration_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.subscription_expiration) +} + +// optional uint32 units_remaining = 11; +inline bool GameAccountBlob::has_units_remaining() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void GameAccountBlob::set_has_units_remaining() { + _has_bits_[0] |= 0x00000100u; +} +inline void GameAccountBlob::clear_has_units_remaining() { + _has_bits_[0] &= ~0x00000100u; +} +inline void GameAccountBlob::clear_units_remaining() { + units_remaining_ = 0u; + clear_has_units_remaining(); +} +inline ::google::protobuf::uint32 GameAccountBlob::units_remaining() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.units_remaining) + return units_remaining_; +} +inline void GameAccountBlob::set_units_remaining(::google::protobuf::uint32 value) { + set_has_units_remaining(); + units_remaining_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.units_remaining) +} + +// optional uint64 status_expiration = 12; +inline bool GameAccountBlob::has_status_expiration() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +inline void GameAccountBlob::set_has_status_expiration() { + _has_bits_[0] |= 0x00000200u; +} +inline void GameAccountBlob::clear_has_status_expiration() { + _has_bits_[0] &= ~0x00000200u; +} +inline void GameAccountBlob::clear_status_expiration() { + status_expiration_ = GOOGLE_ULONGLONG(0); + clear_has_status_expiration(); +} +inline ::google::protobuf::uint64 GameAccountBlob::status_expiration() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.status_expiration) + return status_expiration_; +} +inline void GameAccountBlob::set_status_expiration(::google::protobuf::uint64 value) { + set_has_status_expiration(); + status_expiration_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.status_expiration) +} + +// optional uint32 box_level = 13; +inline bool GameAccountBlob::has_box_level() const { + return (_has_bits_[0] & 0x00000400u) != 0; +} +inline void GameAccountBlob::set_has_box_level() { + _has_bits_[0] |= 0x00000400u; +} +inline void GameAccountBlob::clear_has_box_level() { + _has_bits_[0] &= ~0x00000400u; +} +inline void GameAccountBlob::clear_box_level() { + box_level_ = 0u; + clear_has_box_level(); +} +inline ::google::protobuf::uint32 GameAccountBlob::box_level() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.box_level) + return box_level_; +} +inline void GameAccountBlob::set_box_level(::google::protobuf::uint32 value) { + set_has_box_level(); + box_level_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.box_level) +} + +// optional uint64 box_level_expiration = 14; +inline bool GameAccountBlob::has_box_level_expiration() const { + return (_has_bits_[0] & 0x00000800u) != 0; +} +inline void GameAccountBlob::set_has_box_level_expiration() { + _has_bits_[0] |= 0x00000800u; +} +inline void GameAccountBlob::clear_has_box_level_expiration() { + _has_bits_[0] &= ~0x00000800u; +} +inline void GameAccountBlob::clear_box_level_expiration() { + box_level_expiration_ = GOOGLE_ULONGLONG(0); + clear_has_box_level_expiration(); +} +inline ::google::protobuf::uint64 GameAccountBlob::box_level_expiration() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.box_level_expiration) + return box_level_expiration_; +} +inline void GameAccountBlob::set_box_level_expiration(::google::protobuf::uint64 value) { + set_has_box_level_expiration(); + box_level_expiration_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.box_level_expiration) +} + +// repeated .bgs.protocol.account.v1.AccountLicense licenses = 20; +inline int GameAccountBlob::licenses_size() const { + return licenses_.size(); +} +inline void GameAccountBlob::clear_licenses() { + licenses_.Clear(); +} +inline const ::bgs::protocol::account::v1::AccountLicense& GameAccountBlob::licenses(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.licenses) + return licenses_.Get(index); +} +inline ::bgs::protocol::account::v1::AccountLicense* GameAccountBlob::mutable_licenses(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountBlob.licenses) + return licenses_.Mutable(index); +} +inline ::bgs::protocol::account::v1::AccountLicense* GameAccountBlob::add_licenses() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GameAccountBlob.licenses) + return licenses_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >& +GameAccountBlob::licenses() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GameAccountBlob.licenses) + return licenses_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >* +GameAccountBlob::mutable_licenses() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GameAccountBlob.licenses) + return &licenses_; +} + +// optional fixed32 raf_account = 21; +inline bool GameAccountBlob::has_raf_account() const { + return (_has_bits_[0] & 0x00002000u) != 0; +} +inline void GameAccountBlob::set_has_raf_account() { + _has_bits_[0] |= 0x00002000u; +} +inline void GameAccountBlob::clear_has_raf_account() { + _has_bits_[0] &= ~0x00002000u; +} +inline void GameAccountBlob::clear_raf_account() { + raf_account_ = 0u; + clear_has_raf_account(); +} +inline ::google::protobuf::uint32 GameAccountBlob::raf_account() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.raf_account) + return raf_account_; +} +inline void GameAccountBlob::set_raf_account(::google::protobuf::uint32 value) { + set_has_raf_account(); + raf_account_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.raf_account) +} + +// optional bytes raf_info = 22; +inline bool GameAccountBlob::has_raf_info() const { + return (_has_bits_[0] & 0x00004000u) != 0; +} +inline void GameAccountBlob::set_has_raf_info() { + _has_bits_[0] |= 0x00004000u; +} +inline void GameAccountBlob::clear_has_raf_info() { + _has_bits_[0] &= ~0x00004000u; +} +inline void GameAccountBlob::clear_raf_info() { + if (raf_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + raf_info_->clear(); + } + clear_has_raf_info(); +} +inline const ::std::string& GameAccountBlob::raf_info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.raf_info) + return *raf_info_; +} +inline void GameAccountBlob::set_raf_info(const ::std::string& value) { + set_has_raf_info(); + if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + raf_info_ = new ::std::string; + } + raf_info_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.raf_info) +} +inline void GameAccountBlob::set_raf_info(const char* value) { + set_has_raf_info(); + if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + raf_info_ = new ::std::string; + } + raf_info_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GameAccountBlob.raf_info) +} +inline void GameAccountBlob::set_raf_info(const void* value, size_t size) { + set_has_raf_info(); + if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + raf_info_ = new ::std::string; + } + raf_info_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GameAccountBlob.raf_info) +} +inline ::std::string* GameAccountBlob::mutable_raf_info() { + set_has_raf_info(); + if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + raf_info_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountBlob.raf_info) + return raf_info_; +} +inline ::std::string* GameAccountBlob::release_raf_info() { + clear_has_raf_info(); + if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = raf_info_; + raf_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void GameAccountBlob::set_allocated_raf_info(::std::string* raf_info) { + if (raf_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete raf_info_; + } + if (raf_info) { + set_has_raf_info(); + raf_info_ = raf_info; + } else { + clear_has_raf_info(); + raf_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountBlob.raf_info) +} + +// optional uint64 raf_expiration = 23; +inline bool GameAccountBlob::has_raf_expiration() const { + return (_has_bits_[0] & 0x00008000u) != 0; +} +inline void GameAccountBlob::set_has_raf_expiration() { + _has_bits_[0] |= 0x00008000u; +} +inline void GameAccountBlob::clear_has_raf_expiration() { + _has_bits_[0] &= ~0x00008000u; +} +inline void GameAccountBlob::clear_raf_expiration() { + raf_expiration_ = GOOGLE_ULONGLONG(0); + clear_has_raf_expiration(); +} +inline ::google::protobuf::uint64 GameAccountBlob::raf_expiration() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.raf_expiration) + return raf_expiration_; +} +inline void GameAccountBlob::set_raf_expiration(::google::protobuf::uint64 value) { + set_has_raf_expiration(); + raf_expiration_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.raf_expiration) +} + +// ------------------------------------------------------------------- + +// GameAccountBlobList + +// repeated .bgs.protocol.account.v1.GameAccountBlob blob = 1; +inline int GameAccountBlobList::blob_size() const { + return blob_.size(); +} +inline void GameAccountBlobList::clear_blob() { + blob_.Clear(); +} +inline const ::bgs::protocol::account::v1::GameAccountBlob& GameAccountBlobList::blob(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlobList.blob) + return blob_.Get(index); +} +inline ::bgs::protocol::account::v1::GameAccountBlob* GameAccountBlobList::mutable_blob(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountBlobList.blob) + return blob_.Mutable(index); +} +inline ::bgs::protocol::account::v1::GameAccountBlob* GameAccountBlobList::add_blob() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GameAccountBlobList.blob) + return blob_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountBlob >& +GameAccountBlobList::blob() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GameAccountBlobList.blob) + return blob_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountBlob >* +GameAccountBlobList::mutable_blob() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GameAccountBlobList.blob) + return &blob_; +} + +// ------------------------------------------------------------------- + +// AccountReference + +// optional fixed32 id = 1; +inline bool AccountReference::has_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AccountReference::set_has_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void AccountReference::clear_has_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AccountReference::clear_id() { + id_ = 0u; + clear_has_id(); +} +inline ::google::protobuf::uint32 AccountReference::id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountReference.id) + return id_; +} +inline void AccountReference::set_id(::google::protobuf::uint32 value) { + set_has_id(); + id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountReference.id) +} + +// optional string email = 2; +inline bool AccountReference::has_email() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void AccountReference::set_has_email() { + _has_bits_[0] |= 0x00000002u; +} +inline void AccountReference::clear_has_email() { + _has_bits_[0] &= ~0x00000002u; +} +inline void AccountReference::clear_email() { + if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_->clear(); + } + clear_has_email(); +} +inline const ::std::string& AccountReference::email() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountReference.email) + return *email_; +} +inline void AccountReference::set_email(const ::std::string& value) { + set_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_ = new ::std::string; + } + email_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountReference.email) +} +inline void AccountReference::set_email(const char* value) { + set_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_ = new ::std::string; + } + email_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountReference.email) +} +inline void AccountReference::set_email(const char* value, size_t size) { + set_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_ = new ::std::string; + } + email_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountReference.email) +} +inline ::std::string* AccountReference::mutable_email() { + set_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountReference.email) + return email_; +} +inline ::std::string* AccountReference::release_email() { + clear_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = email_; + email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void AccountReference::set_allocated_email(::std::string* email) { + if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete email_; + } + if (email) { + set_has_email(); + email_ = email; + } else { + clear_has_email(); + email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountReference.email) +} + +// optional .bgs.protocol.account.v1.GameAccountHandle handle = 3; +inline bool AccountReference::has_handle() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void AccountReference::set_has_handle() { + _has_bits_[0] |= 0x00000004u; +} +inline void AccountReference::clear_has_handle() { + _has_bits_[0] &= ~0x00000004u; +} +inline void AccountReference::clear_handle() { + if (handle_ != NULL) handle_->::bgs::protocol::account::v1::GameAccountHandle::Clear(); + clear_has_handle(); +} +inline const ::bgs::protocol::account::v1::GameAccountHandle& AccountReference::handle() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountReference.handle) + return handle_ != NULL ? *handle_ : *default_instance_->handle_; +} +inline ::bgs::protocol::account::v1::GameAccountHandle* AccountReference::mutable_handle() { + set_has_handle(); + if (handle_ == NULL) handle_ = new ::bgs::protocol::account::v1::GameAccountHandle; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountReference.handle) + return handle_; +} +inline ::bgs::protocol::account::v1::GameAccountHandle* AccountReference::release_handle() { + clear_has_handle(); + ::bgs::protocol::account::v1::GameAccountHandle* temp = handle_; + handle_ = NULL; + return temp; +} +inline void AccountReference::set_allocated_handle(::bgs::protocol::account::v1::GameAccountHandle* handle) { + delete handle_; + handle_ = handle; + if (handle) { + set_has_handle(); + } else { + clear_has_handle(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountReference.handle) +} + +// optional string battle_tag = 4; +inline bool AccountReference::has_battle_tag() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void AccountReference::set_has_battle_tag() { + _has_bits_[0] |= 0x00000008u; +} +inline void AccountReference::clear_has_battle_tag() { + _has_bits_[0] &= ~0x00000008u; +} +inline void AccountReference::clear_battle_tag() { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_->clear(); + } + clear_has_battle_tag(); +} +inline const ::std::string& AccountReference::battle_tag() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountReference.battle_tag) + return *battle_tag_; +} +inline void AccountReference::set_battle_tag(const ::std::string& value) { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + battle_tag_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountReference.battle_tag) +} +inline void AccountReference::set_battle_tag(const char* value) { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + battle_tag_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountReference.battle_tag) +} +inline void AccountReference::set_battle_tag(const char* value, size_t size) { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + battle_tag_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountReference.battle_tag) +} +inline ::std::string* AccountReference::mutable_battle_tag() { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountReference.battle_tag) + return battle_tag_; +} +inline ::std::string* AccountReference::release_battle_tag() { + clear_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = battle_tag_; + battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void AccountReference::set_allocated_battle_tag(::std::string* battle_tag) { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete battle_tag_; + } + if (battle_tag) { + set_has_battle_tag(); + battle_tag_ = battle_tag; + } else { + clear_has_battle_tag(); + battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountReference.battle_tag) +} + +// optional uint32 region = 10 [default = 0]; +inline bool AccountReference::has_region() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void AccountReference::set_has_region() { + _has_bits_[0] |= 0x00000010u; +} +inline void AccountReference::clear_has_region() { + _has_bits_[0] &= ~0x00000010u; +} +inline void AccountReference::clear_region() { + region_ = 0u; + clear_has_region(); +} +inline ::google::protobuf::uint32 AccountReference::region() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountReference.region) + return region_; +} +inline void AccountReference::set_region(::google::protobuf::uint32 value) { + set_has_region(); + region_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountReference.region) +} + +// ------------------------------------------------------------------- + +// Identity + +// optional .bgs.protocol.account.v1.AccountId account = 1; +inline bool Identity::has_account() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Identity::set_has_account() { + _has_bits_[0] |= 0x00000001u; +} +inline void Identity::clear_has_account() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Identity::clear_account() { + if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear(); + clear_has_account(); +} +inline const ::bgs::protocol::account::v1::AccountId& Identity::account() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.Identity.account) + return account_ != NULL ? *account_ : *default_instance_->account_; +} +inline ::bgs::protocol::account::v1::AccountId* Identity::mutable_account() { + set_has_account(); + if (account_ == NULL) account_ = new ::bgs::protocol::account::v1::AccountId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.Identity.account) + return account_; +} +inline ::bgs::protocol::account::v1::AccountId* Identity::release_account() { + clear_has_account(); + ::bgs::protocol::account::v1::AccountId* temp = account_; + account_ = NULL; + return temp; +} +inline void Identity::set_allocated_account(::bgs::protocol::account::v1::AccountId* account) { + delete account_; + account_ = account; + if (account) { + set_has_account(); + } else { + clear_has_account(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.Identity.account) +} + +// optional .bgs.protocol.account.v1.GameAccountHandle game_account = 2; +inline bool Identity::has_game_account() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Identity::set_has_game_account() { + _has_bits_[0] |= 0x00000002u; +} +inline void Identity::clear_has_game_account() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Identity::clear_game_account() { + if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear(); + clear_has_game_account(); +} +inline const ::bgs::protocol::account::v1::GameAccountHandle& Identity::game_account() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.Identity.game_account) + return game_account_ != NULL ? *game_account_ : *default_instance_->game_account_; +} +inline ::bgs::protocol::account::v1::GameAccountHandle* Identity::mutable_game_account() { + set_has_game_account(); + if (game_account_ == NULL) game_account_ = new ::bgs::protocol::account::v1::GameAccountHandle; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.Identity.game_account) + return game_account_; +} +inline ::bgs::protocol::account::v1::GameAccountHandle* Identity::release_game_account() { + clear_has_game_account(); + ::bgs::protocol::account::v1::GameAccountHandle* temp = game_account_; + game_account_ = NULL; + return temp; +} +inline void Identity::set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account) { + delete game_account_; + game_account_ = game_account; + if (game_account) { + set_has_game_account(); + } else { + clear_has_game_account(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.Identity.game_account) +} + +// optional .bgs.protocol.ProcessId process = 3; +inline bool Identity::has_process() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void Identity::set_has_process() { + _has_bits_[0] |= 0x00000004u; +} +inline void Identity::clear_has_process() { + _has_bits_[0] &= ~0x00000004u; +} +inline void Identity::clear_process() { + if (process_ != NULL) process_->::bgs::protocol::ProcessId::Clear(); + clear_has_process(); +} +inline const ::bgs::protocol::ProcessId& Identity::process() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.Identity.process) + return process_ != NULL ? *process_ : *default_instance_->process_; +} +inline ::bgs::protocol::ProcessId* Identity::mutable_process() { + set_has_process(); + if (process_ == NULL) process_ = new ::bgs::protocol::ProcessId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.Identity.process) + return process_; +} +inline ::bgs::protocol::ProcessId* Identity::release_process() { + clear_has_process(); + ::bgs::protocol::ProcessId* temp = process_; + process_ = NULL; + return temp; +} +inline void Identity::set_allocated_process(::bgs::protocol::ProcessId* process) { + delete process_; + process_ = process; + if (process) { + set_has_process(); + } else { + clear_has_process(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.Identity.process) +} + +// ------------------------------------------------------------------- + +// ProgramTag + +// optional fixed32 program = 1; +inline bool ProgramTag::has_program() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ProgramTag::set_has_program() { + _has_bits_[0] |= 0x00000001u; +} +inline void ProgramTag::clear_has_program() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ProgramTag::clear_program() { + program_ = 0u; + clear_has_program(); +} +inline ::google::protobuf::uint32 ProgramTag::program() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ProgramTag.program) + return program_; +} +inline void ProgramTag::set_program(::google::protobuf::uint32 value) { + set_has_program(); + program_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ProgramTag.program) +} + +// optional fixed32 tag = 2; +inline bool ProgramTag::has_tag() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ProgramTag::set_has_tag() { + _has_bits_[0] |= 0x00000002u; +} +inline void ProgramTag::clear_has_tag() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ProgramTag::clear_tag() { + tag_ = 0u; + clear_has_tag(); +} +inline ::google::protobuf::uint32 ProgramTag::tag() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ProgramTag.tag) + return tag_; +} +inline void ProgramTag::set_tag(::google::protobuf::uint32 value) { + set_has_tag(); + tag_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ProgramTag.tag) +} + +// ------------------------------------------------------------------- + +// RegionTag + +// optional fixed32 region = 1; +inline bool RegionTag::has_region() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void RegionTag::set_has_region() { + _has_bits_[0] |= 0x00000001u; +} +inline void RegionTag::clear_has_region() { + _has_bits_[0] &= ~0x00000001u; +} +inline void RegionTag::clear_region() { + region_ = 0u; + clear_has_region(); +} +inline ::google::protobuf::uint32 RegionTag::region() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.RegionTag.region) + return region_; +} +inline void RegionTag::set_region(::google::protobuf::uint32 value) { + set_has_region(); + region_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.RegionTag.region) +} + +// optional fixed32 tag = 2; +inline bool RegionTag::has_tag() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void RegionTag::set_has_tag() { + _has_bits_[0] |= 0x00000002u; +} +inline void RegionTag::clear_has_tag() { + _has_bits_[0] &= ~0x00000002u; +} +inline void RegionTag::clear_tag() { + tag_ = 0u; + clear_has_tag(); +} +inline ::google::protobuf::uint32 RegionTag::tag() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.RegionTag.tag) + return tag_; +} +inline void RegionTag::set_tag(::google::protobuf::uint32 value) { + set_has_tag(); + tag_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.RegionTag.tag) +} + +// ------------------------------------------------------------------- + +// AccountFieldTags + +// optional fixed32 account_level_info_tag = 2; +inline bool AccountFieldTags::has_account_level_info_tag() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AccountFieldTags::set_has_account_level_info_tag() { + _has_bits_[0] |= 0x00000001u; +} +inline void AccountFieldTags::clear_has_account_level_info_tag() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AccountFieldTags::clear_account_level_info_tag() { + account_level_info_tag_ = 0u; + clear_has_account_level_info_tag(); +} +inline ::google::protobuf::uint32 AccountFieldTags::account_level_info_tag() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldTags.account_level_info_tag) + return account_level_info_tag_; +} +inline void AccountFieldTags::set_account_level_info_tag(::google::protobuf::uint32 value) { + set_has_account_level_info_tag(); + account_level_info_tag_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFieldTags.account_level_info_tag) +} + +// optional fixed32 privacy_info_tag = 3; +inline bool AccountFieldTags::has_privacy_info_tag() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void AccountFieldTags::set_has_privacy_info_tag() { + _has_bits_[0] |= 0x00000002u; +} +inline void AccountFieldTags::clear_has_privacy_info_tag() { + _has_bits_[0] &= ~0x00000002u; +} +inline void AccountFieldTags::clear_privacy_info_tag() { + privacy_info_tag_ = 0u; + clear_has_privacy_info_tag(); +} +inline ::google::protobuf::uint32 AccountFieldTags::privacy_info_tag() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldTags.privacy_info_tag) + return privacy_info_tag_; +} +inline void AccountFieldTags::set_privacy_info_tag(::google::protobuf::uint32 value) { + set_has_privacy_info_tag(); + privacy_info_tag_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFieldTags.privacy_info_tag) +} + +// optional fixed32 parental_control_info_tag = 4; +inline bool AccountFieldTags::has_parental_control_info_tag() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void AccountFieldTags::set_has_parental_control_info_tag() { + _has_bits_[0] |= 0x00000004u; +} +inline void AccountFieldTags::clear_has_parental_control_info_tag() { + _has_bits_[0] &= ~0x00000004u; +} +inline void AccountFieldTags::clear_parental_control_info_tag() { + parental_control_info_tag_ = 0u; + clear_has_parental_control_info_tag(); +} +inline ::google::protobuf::uint32 AccountFieldTags::parental_control_info_tag() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldTags.parental_control_info_tag) + return parental_control_info_tag_; +} +inline void AccountFieldTags::set_parental_control_info_tag(::google::protobuf::uint32 value) { + set_has_parental_control_info_tag(); + parental_control_info_tag_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFieldTags.parental_control_info_tag) +} + +// repeated .bgs.protocol.account.v1.ProgramTag game_level_info_tags = 7; +inline int AccountFieldTags::game_level_info_tags_size() const { + return game_level_info_tags_.size(); +} +inline void AccountFieldTags::clear_game_level_info_tags() { + game_level_info_tags_.Clear(); +} +inline const ::bgs::protocol::account::v1::ProgramTag& AccountFieldTags::game_level_info_tags(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldTags.game_level_info_tags) + return game_level_info_tags_.Get(index); +} +inline ::bgs::protocol::account::v1::ProgramTag* AccountFieldTags::mutable_game_level_info_tags(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountFieldTags.game_level_info_tags) + return game_level_info_tags_.Mutable(index); +} +inline ::bgs::protocol::account::v1::ProgramTag* AccountFieldTags::add_game_level_info_tags() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountFieldTags.game_level_info_tags) + return game_level_info_tags_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::ProgramTag >& +AccountFieldTags::game_level_info_tags() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountFieldTags.game_level_info_tags) + return game_level_info_tags_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::ProgramTag >* +AccountFieldTags::mutable_game_level_info_tags() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountFieldTags.game_level_info_tags) + return &game_level_info_tags_; +} + +// repeated .bgs.protocol.account.v1.ProgramTag game_status_tags = 9; +inline int AccountFieldTags::game_status_tags_size() const { + return game_status_tags_.size(); +} +inline void AccountFieldTags::clear_game_status_tags() { + game_status_tags_.Clear(); +} +inline const ::bgs::protocol::account::v1::ProgramTag& AccountFieldTags::game_status_tags(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldTags.game_status_tags) + return game_status_tags_.Get(index); +} +inline ::bgs::protocol::account::v1::ProgramTag* AccountFieldTags::mutable_game_status_tags(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountFieldTags.game_status_tags) + return game_status_tags_.Mutable(index); +} +inline ::bgs::protocol::account::v1::ProgramTag* AccountFieldTags::add_game_status_tags() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountFieldTags.game_status_tags) + return game_status_tags_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::ProgramTag >& +AccountFieldTags::game_status_tags() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountFieldTags.game_status_tags) + return game_status_tags_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::ProgramTag >* +AccountFieldTags::mutable_game_status_tags() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountFieldTags.game_status_tags) + return &game_status_tags_; +} + +// repeated .bgs.protocol.account.v1.RegionTag game_account_tags = 11; +inline int AccountFieldTags::game_account_tags_size() const { + return game_account_tags_.size(); +} +inline void AccountFieldTags::clear_game_account_tags() { + game_account_tags_.Clear(); +} +inline const ::bgs::protocol::account::v1::RegionTag& AccountFieldTags::game_account_tags(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldTags.game_account_tags) + return game_account_tags_.Get(index); +} +inline ::bgs::protocol::account::v1::RegionTag* AccountFieldTags::mutable_game_account_tags(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountFieldTags.game_account_tags) + return game_account_tags_.Mutable(index); +} +inline ::bgs::protocol::account::v1::RegionTag* AccountFieldTags::add_game_account_tags() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountFieldTags.game_account_tags) + return game_account_tags_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::RegionTag >& +AccountFieldTags::game_account_tags() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountFieldTags.game_account_tags) + return game_account_tags_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::RegionTag >* +AccountFieldTags::mutable_game_account_tags() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountFieldTags.game_account_tags) + return &game_account_tags_; +} + +// ------------------------------------------------------------------- + +// GameAccountFieldTags + +// optional fixed32 game_level_info_tag = 2; +inline bool GameAccountFieldTags::has_game_level_info_tag() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GameAccountFieldTags::set_has_game_level_info_tag() { + _has_bits_[0] |= 0x00000001u; +} +inline void GameAccountFieldTags::clear_has_game_level_info_tag() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GameAccountFieldTags::clear_game_level_info_tag() { + game_level_info_tag_ = 0u; + clear_has_game_level_info_tag(); +} +inline ::google::protobuf::uint32 GameAccountFieldTags::game_level_info_tag() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFieldTags.game_level_info_tag) + return game_level_info_tag_; +} +inline void GameAccountFieldTags::set_game_level_info_tag(::google::protobuf::uint32 value) { + set_has_game_level_info_tag(); + game_level_info_tag_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountFieldTags.game_level_info_tag) +} + +// optional fixed32 game_time_info_tag = 3; +inline bool GameAccountFieldTags::has_game_time_info_tag() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GameAccountFieldTags::set_has_game_time_info_tag() { + _has_bits_[0] |= 0x00000002u; +} +inline void GameAccountFieldTags::clear_has_game_time_info_tag() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GameAccountFieldTags::clear_game_time_info_tag() { + game_time_info_tag_ = 0u; + clear_has_game_time_info_tag(); +} +inline ::google::protobuf::uint32 GameAccountFieldTags::game_time_info_tag() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFieldTags.game_time_info_tag) + return game_time_info_tag_; +} +inline void GameAccountFieldTags::set_game_time_info_tag(::google::protobuf::uint32 value) { + set_has_game_time_info_tag(); + game_time_info_tag_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountFieldTags.game_time_info_tag) +} + +// optional fixed32 game_status_tag = 4; +inline bool GameAccountFieldTags::has_game_status_tag() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GameAccountFieldTags::set_has_game_status_tag() { + _has_bits_[0] |= 0x00000004u; +} +inline void GameAccountFieldTags::clear_has_game_status_tag() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GameAccountFieldTags::clear_game_status_tag() { + game_status_tag_ = 0u; + clear_has_game_status_tag(); +} +inline ::google::protobuf::uint32 GameAccountFieldTags::game_status_tag() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFieldTags.game_status_tag) + return game_status_tag_; +} +inline void GameAccountFieldTags::set_game_status_tag(::google::protobuf::uint32 value) { + set_has_game_status_tag(); + game_status_tag_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountFieldTags.game_status_tag) +} + +// optional fixed32 raf_info_tag = 5; +inline bool GameAccountFieldTags::has_raf_info_tag() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void GameAccountFieldTags::set_has_raf_info_tag() { + _has_bits_[0] |= 0x00000008u; +} +inline void GameAccountFieldTags::clear_has_raf_info_tag() { + _has_bits_[0] &= ~0x00000008u; +} +inline void GameAccountFieldTags::clear_raf_info_tag() { + raf_info_tag_ = 0u; + clear_has_raf_info_tag(); +} +inline ::google::protobuf::uint32 GameAccountFieldTags::raf_info_tag() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFieldTags.raf_info_tag) + return raf_info_tag_; +} +inline void GameAccountFieldTags::set_raf_info_tag(::google::protobuf::uint32 value) { + set_has_raf_info_tag(); + raf_info_tag_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountFieldTags.raf_info_tag) +} + +// ------------------------------------------------------------------- + +// AccountFieldOptions + +// optional bool all_fields = 1; +inline bool AccountFieldOptions::has_all_fields() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AccountFieldOptions::set_has_all_fields() { + _has_bits_[0] |= 0x00000001u; +} +inline void AccountFieldOptions::clear_has_all_fields() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AccountFieldOptions::clear_all_fields() { + all_fields_ = false; + clear_has_all_fields(); +} +inline bool AccountFieldOptions::all_fields() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldOptions.all_fields) + return all_fields_; +} +inline void AccountFieldOptions::set_all_fields(bool value) { + set_has_all_fields(); + all_fields_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFieldOptions.all_fields) +} + +// optional bool field_account_level_info = 2; +inline bool AccountFieldOptions::has_field_account_level_info() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void AccountFieldOptions::set_has_field_account_level_info() { + _has_bits_[0] |= 0x00000002u; +} +inline void AccountFieldOptions::clear_has_field_account_level_info() { + _has_bits_[0] &= ~0x00000002u; +} +inline void AccountFieldOptions::clear_field_account_level_info() { + field_account_level_info_ = false; + clear_has_field_account_level_info(); +} +inline bool AccountFieldOptions::field_account_level_info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldOptions.field_account_level_info) + return field_account_level_info_; +} +inline void AccountFieldOptions::set_field_account_level_info(bool value) { + set_has_field_account_level_info(); + field_account_level_info_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFieldOptions.field_account_level_info) +} + +// optional bool field_privacy_info = 3; +inline bool AccountFieldOptions::has_field_privacy_info() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void AccountFieldOptions::set_has_field_privacy_info() { + _has_bits_[0] |= 0x00000004u; +} +inline void AccountFieldOptions::clear_has_field_privacy_info() { + _has_bits_[0] &= ~0x00000004u; +} +inline void AccountFieldOptions::clear_field_privacy_info() { + field_privacy_info_ = false; + clear_has_field_privacy_info(); +} +inline bool AccountFieldOptions::field_privacy_info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldOptions.field_privacy_info) + return field_privacy_info_; +} +inline void AccountFieldOptions::set_field_privacy_info(bool value) { + set_has_field_privacy_info(); + field_privacy_info_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFieldOptions.field_privacy_info) +} + +// optional bool field_parental_control_info = 4; +inline bool AccountFieldOptions::has_field_parental_control_info() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void AccountFieldOptions::set_has_field_parental_control_info() { + _has_bits_[0] |= 0x00000008u; +} +inline void AccountFieldOptions::clear_has_field_parental_control_info() { + _has_bits_[0] &= ~0x00000008u; +} +inline void AccountFieldOptions::clear_field_parental_control_info() { + field_parental_control_info_ = false; + clear_has_field_parental_control_info(); +} +inline bool AccountFieldOptions::field_parental_control_info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldOptions.field_parental_control_info) + return field_parental_control_info_; +} +inline void AccountFieldOptions::set_field_parental_control_info(bool value) { + set_has_field_parental_control_info(); + field_parental_control_info_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFieldOptions.field_parental_control_info) +} + +// optional bool field_game_level_info = 6; +inline bool AccountFieldOptions::has_field_game_level_info() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void AccountFieldOptions::set_has_field_game_level_info() { + _has_bits_[0] |= 0x00000010u; +} +inline void AccountFieldOptions::clear_has_field_game_level_info() { + _has_bits_[0] &= ~0x00000010u; +} +inline void AccountFieldOptions::clear_field_game_level_info() { + field_game_level_info_ = false; + clear_has_field_game_level_info(); +} +inline bool AccountFieldOptions::field_game_level_info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldOptions.field_game_level_info) + return field_game_level_info_; +} +inline void AccountFieldOptions::set_field_game_level_info(bool value) { + set_has_field_game_level_info(); + field_game_level_info_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFieldOptions.field_game_level_info) +} + +// optional bool field_game_status = 7; +inline bool AccountFieldOptions::has_field_game_status() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void AccountFieldOptions::set_has_field_game_status() { + _has_bits_[0] |= 0x00000020u; +} +inline void AccountFieldOptions::clear_has_field_game_status() { + _has_bits_[0] &= ~0x00000020u; +} +inline void AccountFieldOptions::clear_field_game_status() { + field_game_status_ = false; + clear_has_field_game_status(); +} +inline bool AccountFieldOptions::field_game_status() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldOptions.field_game_status) + return field_game_status_; +} +inline void AccountFieldOptions::set_field_game_status(bool value) { + set_has_field_game_status(); + field_game_status_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFieldOptions.field_game_status) +} + +// optional bool field_game_accounts = 8; +inline bool AccountFieldOptions::has_field_game_accounts() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void AccountFieldOptions::set_has_field_game_accounts() { + _has_bits_[0] |= 0x00000040u; +} +inline void AccountFieldOptions::clear_has_field_game_accounts() { + _has_bits_[0] &= ~0x00000040u; +} +inline void AccountFieldOptions::clear_field_game_accounts() { + field_game_accounts_ = false; + clear_has_field_game_accounts(); +} +inline bool AccountFieldOptions::field_game_accounts() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldOptions.field_game_accounts) + return field_game_accounts_; +} +inline void AccountFieldOptions::set_field_game_accounts(bool value) { + set_has_field_game_accounts(); + field_game_accounts_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFieldOptions.field_game_accounts) +} + +// ------------------------------------------------------------------- + +// GameAccountFieldOptions + +// optional bool all_fields = 1; +inline bool GameAccountFieldOptions::has_all_fields() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GameAccountFieldOptions::set_has_all_fields() { + _has_bits_[0] |= 0x00000001u; +} +inline void GameAccountFieldOptions::clear_has_all_fields() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GameAccountFieldOptions::clear_all_fields() { + all_fields_ = false; + clear_has_all_fields(); +} +inline bool GameAccountFieldOptions::all_fields() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFieldOptions.all_fields) + return all_fields_; +} +inline void GameAccountFieldOptions::set_all_fields(bool value) { + set_has_all_fields(); + all_fields_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountFieldOptions.all_fields) +} + +// optional bool field_game_level_info = 2; +inline bool GameAccountFieldOptions::has_field_game_level_info() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GameAccountFieldOptions::set_has_field_game_level_info() { + _has_bits_[0] |= 0x00000002u; +} +inline void GameAccountFieldOptions::clear_has_field_game_level_info() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GameAccountFieldOptions::clear_field_game_level_info() { + field_game_level_info_ = false; + clear_has_field_game_level_info(); +} +inline bool GameAccountFieldOptions::field_game_level_info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFieldOptions.field_game_level_info) + return field_game_level_info_; +} +inline void GameAccountFieldOptions::set_field_game_level_info(bool value) { + set_has_field_game_level_info(); + field_game_level_info_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountFieldOptions.field_game_level_info) +} + +// optional bool field_game_time_info = 3; +inline bool GameAccountFieldOptions::has_field_game_time_info() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GameAccountFieldOptions::set_has_field_game_time_info() { + _has_bits_[0] |= 0x00000004u; +} +inline void GameAccountFieldOptions::clear_has_field_game_time_info() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GameAccountFieldOptions::clear_field_game_time_info() { + field_game_time_info_ = false; + clear_has_field_game_time_info(); +} +inline bool GameAccountFieldOptions::field_game_time_info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFieldOptions.field_game_time_info) + return field_game_time_info_; +} +inline void GameAccountFieldOptions::set_field_game_time_info(bool value) { + set_has_field_game_time_info(); + field_game_time_info_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountFieldOptions.field_game_time_info) +} + +// optional bool field_game_status = 4; +inline bool GameAccountFieldOptions::has_field_game_status() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void GameAccountFieldOptions::set_has_field_game_status() { + _has_bits_[0] |= 0x00000008u; +} +inline void GameAccountFieldOptions::clear_has_field_game_status() { + _has_bits_[0] &= ~0x00000008u; +} +inline void GameAccountFieldOptions::clear_field_game_status() { + field_game_status_ = false; + clear_has_field_game_status(); +} +inline bool GameAccountFieldOptions::field_game_status() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFieldOptions.field_game_status) + return field_game_status_; +} +inline void GameAccountFieldOptions::set_field_game_status(bool value) { + set_has_field_game_status(); + field_game_status_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountFieldOptions.field_game_status) +} + +// optional bool field_raf_info = 5; +inline bool GameAccountFieldOptions::has_field_raf_info() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void GameAccountFieldOptions::set_has_field_raf_info() { + _has_bits_[0] |= 0x00000010u; +} +inline void GameAccountFieldOptions::clear_has_field_raf_info() { + _has_bits_[0] &= ~0x00000010u; +} +inline void GameAccountFieldOptions::clear_field_raf_info() { + field_raf_info_ = false; + clear_has_field_raf_info(); +} +inline bool GameAccountFieldOptions::field_raf_info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFieldOptions.field_raf_info) + return field_raf_info_; +} +inline void GameAccountFieldOptions::set_field_raf_info(bool value) { + set_has_field_raf_info(); + field_raf_info_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountFieldOptions.field_raf_info) +} + +// ------------------------------------------------------------------- + +// SubscriberReference + +// optional uint64 object_id = 1 [default = 0]; +inline bool SubscriberReference::has_object_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SubscriberReference::set_has_object_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void SubscriberReference::clear_has_object_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SubscriberReference::clear_object_id() { + object_id_ = GOOGLE_ULONGLONG(0); + clear_has_object_id(); +} +inline ::google::protobuf::uint64 SubscriberReference::object_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SubscriberReference.object_id) + return object_id_; +} +inline void SubscriberReference::set_object_id(::google::protobuf::uint64 value) { + set_has_object_id(); + object_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.SubscriberReference.object_id) +} + +// optional .bgs.protocol.EntityId entity_id = 2; +inline bool SubscriberReference::has_entity_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void SubscriberReference::set_has_entity_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void SubscriberReference::clear_has_entity_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void SubscriberReference::clear_entity_id() { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + clear_has_entity_id(); +} +inline const ::bgs::protocol::EntityId& SubscriberReference::entity_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SubscriberReference.entity_id) + return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_; +} +inline ::bgs::protocol::EntityId* SubscriberReference::mutable_entity_id() { + set_has_entity_id(); + if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.SubscriberReference.entity_id) + return entity_id_; +} +inline ::bgs::protocol::EntityId* SubscriberReference::release_entity_id() { + clear_has_entity_id(); + ::bgs::protocol::EntityId* temp = entity_id_; + entity_id_ = NULL; + return temp; +} +inline void SubscriberReference::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) { + delete entity_id_; + entity_id_ = entity_id; + if (entity_id) { + set_has_entity_id(); + } else { + clear_has_entity_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.SubscriberReference.entity_id) +} + +// optional .bgs.protocol.account.v1.AccountFieldOptions account_options = 3; +inline bool SubscriberReference::has_account_options() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void SubscriberReference::set_has_account_options() { + _has_bits_[0] |= 0x00000004u; +} +inline void SubscriberReference::clear_has_account_options() { + _has_bits_[0] &= ~0x00000004u; +} +inline void SubscriberReference::clear_account_options() { + if (account_options_ != NULL) account_options_->::bgs::protocol::account::v1::AccountFieldOptions::Clear(); + clear_has_account_options(); +} +inline const ::bgs::protocol::account::v1::AccountFieldOptions& SubscriberReference::account_options() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SubscriberReference.account_options) + return account_options_ != NULL ? *account_options_ : *default_instance_->account_options_; +} +inline ::bgs::protocol::account::v1::AccountFieldOptions* SubscriberReference::mutable_account_options() { + set_has_account_options(); + if (account_options_ == NULL) account_options_ = new ::bgs::protocol::account::v1::AccountFieldOptions; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.SubscriberReference.account_options) + return account_options_; +} +inline ::bgs::protocol::account::v1::AccountFieldOptions* SubscriberReference::release_account_options() { + clear_has_account_options(); + ::bgs::protocol::account::v1::AccountFieldOptions* temp = account_options_; + account_options_ = NULL; + return temp; +} +inline void SubscriberReference::set_allocated_account_options(::bgs::protocol::account::v1::AccountFieldOptions* account_options) { + delete account_options_; + account_options_ = account_options; + if (account_options) { + set_has_account_options(); + } else { + clear_has_account_options(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.SubscriberReference.account_options) +} + +// optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 4; +inline bool SubscriberReference::has_account_tags() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void SubscriberReference::set_has_account_tags() { + _has_bits_[0] |= 0x00000008u; +} +inline void SubscriberReference::clear_has_account_tags() { + _has_bits_[0] &= ~0x00000008u; +} +inline void SubscriberReference::clear_account_tags() { + if (account_tags_ != NULL) account_tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear(); + clear_has_account_tags(); +} +inline const ::bgs::protocol::account::v1::AccountFieldTags& SubscriberReference::account_tags() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SubscriberReference.account_tags) + return account_tags_ != NULL ? *account_tags_ : *default_instance_->account_tags_; +} +inline ::bgs::protocol::account::v1::AccountFieldTags* SubscriberReference::mutable_account_tags() { + set_has_account_tags(); + if (account_tags_ == NULL) account_tags_ = new ::bgs::protocol::account::v1::AccountFieldTags; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.SubscriberReference.account_tags) + return account_tags_; +} +inline ::bgs::protocol::account::v1::AccountFieldTags* SubscriberReference::release_account_tags() { + clear_has_account_tags(); + ::bgs::protocol::account::v1::AccountFieldTags* temp = account_tags_; + account_tags_ = NULL; + return temp; +} +inline void SubscriberReference::set_allocated_account_tags(::bgs::protocol::account::v1::AccountFieldTags* account_tags) { + delete account_tags_; + account_tags_ = account_tags; + if (account_tags) { + set_has_account_tags(); + } else { + clear_has_account_tags(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.SubscriberReference.account_tags) +} + +// optional .bgs.protocol.account.v1.GameAccountFieldOptions game_account_options = 5; +inline bool SubscriberReference::has_game_account_options() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void SubscriberReference::set_has_game_account_options() { + _has_bits_[0] |= 0x00000010u; +} +inline void SubscriberReference::clear_has_game_account_options() { + _has_bits_[0] &= ~0x00000010u; +} +inline void SubscriberReference::clear_game_account_options() { + if (game_account_options_ != NULL) game_account_options_->::bgs::protocol::account::v1::GameAccountFieldOptions::Clear(); + clear_has_game_account_options(); +} +inline const ::bgs::protocol::account::v1::GameAccountFieldOptions& SubscriberReference::game_account_options() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SubscriberReference.game_account_options) + return game_account_options_ != NULL ? *game_account_options_ : *default_instance_->game_account_options_; +} +inline ::bgs::protocol::account::v1::GameAccountFieldOptions* SubscriberReference::mutable_game_account_options() { + set_has_game_account_options(); + if (game_account_options_ == NULL) game_account_options_ = new ::bgs::protocol::account::v1::GameAccountFieldOptions; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.SubscriberReference.game_account_options) + return game_account_options_; +} +inline ::bgs::protocol::account::v1::GameAccountFieldOptions* SubscriberReference::release_game_account_options() { + clear_has_game_account_options(); + ::bgs::protocol::account::v1::GameAccountFieldOptions* temp = game_account_options_; + game_account_options_ = NULL; + return temp; +} +inline void SubscriberReference::set_allocated_game_account_options(::bgs::protocol::account::v1::GameAccountFieldOptions* game_account_options) { + delete game_account_options_; + game_account_options_ = game_account_options; + if (game_account_options) { + set_has_game_account_options(); + } else { + clear_has_game_account_options(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.SubscriberReference.game_account_options) +} + +// optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 6; +inline bool SubscriberReference::has_game_account_tags() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void SubscriberReference::set_has_game_account_tags() { + _has_bits_[0] |= 0x00000020u; +} +inline void SubscriberReference::clear_has_game_account_tags() { + _has_bits_[0] &= ~0x00000020u; +} +inline void SubscriberReference::clear_game_account_tags() { + if (game_account_tags_ != NULL) game_account_tags_->::bgs::protocol::account::v1::GameAccountFieldTags::Clear(); + clear_has_game_account_tags(); +} +inline const ::bgs::protocol::account::v1::GameAccountFieldTags& SubscriberReference::game_account_tags() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SubscriberReference.game_account_tags) + return game_account_tags_ != NULL ? *game_account_tags_ : *default_instance_->game_account_tags_; +} +inline ::bgs::protocol::account::v1::GameAccountFieldTags* SubscriberReference::mutable_game_account_tags() { + set_has_game_account_tags(); + if (game_account_tags_ == NULL) game_account_tags_ = new ::bgs::protocol::account::v1::GameAccountFieldTags; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.SubscriberReference.game_account_tags) + return game_account_tags_; +} +inline ::bgs::protocol::account::v1::GameAccountFieldTags* SubscriberReference::release_game_account_tags() { + clear_has_game_account_tags(); + ::bgs::protocol::account::v1::GameAccountFieldTags* temp = game_account_tags_; + game_account_tags_ = NULL; + return temp; +} +inline void SubscriberReference::set_allocated_game_account_tags(::bgs::protocol::account::v1::GameAccountFieldTags* game_account_tags) { + delete game_account_tags_; + game_account_tags_ = game_account_tags; + if (game_account_tags) { + set_has_game_account_tags(); + } else { + clear_has_game_account_tags(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.SubscriberReference.game_account_tags) +} + +// optional uint64 subscriber_id = 7 [default = 0]; +inline bool SubscriberReference::has_subscriber_id() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void SubscriberReference::set_has_subscriber_id() { + _has_bits_[0] |= 0x00000040u; +} +inline void SubscriberReference::clear_has_subscriber_id() { + _has_bits_[0] &= ~0x00000040u; +} +inline void SubscriberReference::clear_subscriber_id() { + subscriber_id_ = GOOGLE_ULONGLONG(0); + clear_has_subscriber_id(); +} +inline ::google::protobuf::uint64 SubscriberReference::subscriber_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SubscriberReference.subscriber_id) + return subscriber_id_; +} +inline void SubscriberReference::set_subscriber_id(::google::protobuf::uint64 value) { + set_has_subscriber_id(); + subscriber_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.SubscriberReference.subscriber_id) +} + +// ------------------------------------------------------------------- + +// AccountLevelInfo + +// repeated .bgs.protocol.account.v1.AccountLicense licenses = 3; +inline int AccountLevelInfo::licenses_size() const { + return licenses_.size(); +} +inline void AccountLevelInfo::clear_licenses() { + licenses_.Clear(); +} +inline const ::bgs::protocol::account::v1::AccountLicense& AccountLevelInfo::licenses(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.licenses) + return licenses_.Get(index); +} +inline ::bgs::protocol::account::v1::AccountLicense* AccountLevelInfo::mutable_licenses(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountLevelInfo.licenses) + return licenses_.Mutable(index); +} +inline ::bgs::protocol::account::v1::AccountLicense* AccountLevelInfo::add_licenses() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountLevelInfo.licenses) + return licenses_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >& +AccountLevelInfo::licenses() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountLevelInfo.licenses) + return licenses_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >* +AccountLevelInfo::mutable_licenses() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountLevelInfo.licenses) + return &licenses_; +} + +// optional fixed32 default_currency = 4; +inline bool AccountLevelInfo::has_default_currency() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void AccountLevelInfo::set_has_default_currency() { + _has_bits_[0] |= 0x00000002u; +} +inline void AccountLevelInfo::clear_has_default_currency() { + _has_bits_[0] &= ~0x00000002u; +} +inline void AccountLevelInfo::clear_default_currency() { + default_currency_ = 0u; + clear_has_default_currency(); +} +inline ::google::protobuf::uint32 AccountLevelInfo::default_currency() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.default_currency) + return default_currency_; +} +inline void AccountLevelInfo::set_default_currency(::google::protobuf::uint32 value) { + set_has_default_currency(); + default_currency_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.default_currency) +} + +// optional string country = 5; +inline bool AccountLevelInfo::has_country() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void AccountLevelInfo::set_has_country() { + _has_bits_[0] |= 0x00000004u; +} +inline void AccountLevelInfo::clear_has_country() { + _has_bits_[0] &= ~0x00000004u; +} +inline void AccountLevelInfo::clear_country() { + if (country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + country_->clear(); + } + clear_has_country(); +} +inline const ::std::string& AccountLevelInfo::country() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.country) + return *country_; +} +inline void AccountLevelInfo::set_country(const ::std::string& value) { + set_has_country(); + if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + country_ = new ::std::string; + } + country_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.country) +} +inline void AccountLevelInfo::set_country(const char* value) { + set_has_country(); + if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + country_ = new ::std::string; + } + country_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountLevelInfo.country) +} +inline void AccountLevelInfo::set_country(const char* value, size_t size) { + set_has_country(); + if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + country_ = new ::std::string; + } + country_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountLevelInfo.country) +} +inline ::std::string* AccountLevelInfo::mutable_country() { + set_has_country(); + if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + country_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountLevelInfo.country) + return country_; +} +inline ::std::string* AccountLevelInfo::release_country() { + clear_has_country(); + if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = country_; + country_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void AccountLevelInfo::set_allocated_country(::std::string* country) { + if (country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete country_; + } + if (country) { + set_has_country(); + country_ = country; + } else { + clear_has_country(); + country_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountLevelInfo.country) +} + +// optional uint32 preferred_region = 6; +inline bool AccountLevelInfo::has_preferred_region() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void AccountLevelInfo::set_has_preferred_region() { + _has_bits_[0] |= 0x00000008u; +} +inline void AccountLevelInfo::clear_has_preferred_region() { + _has_bits_[0] &= ~0x00000008u; +} +inline void AccountLevelInfo::clear_preferred_region() { + preferred_region_ = 0u; + clear_has_preferred_region(); +} +inline ::google::protobuf::uint32 AccountLevelInfo::preferred_region() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.preferred_region) + return preferred_region_; +} +inline void AccountLevelInfo::set_preferred_region(::google::protobuf::uint32 value) { + set_has_preferred_region(); + preferred_region_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.preferred_region) +} + +// optional string full_name = 7; +inline bool AccountLevelInfo::has_full_name() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void AccountLevelInfo::set_has_full_name() { + _has_bits_[0] |= 0x00000010u; +} +inline void AccountLevelInfo::clear_has_full_name() { + _has_bits_[0] &= ~0x00000010u; +} +inline void AccountLevelInfo::clear_full_name() { + if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + full_name_->clear(); + } + clear_has_full_name(); +} +inline const ::std::string& AccountLevelInfo::full_name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.full_name) + return *full_name_; +} +inline void AccountLevelInfo::set_full_name(const ::std::string& value) { + set_has_full_name(); + if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + full_name_ = new ::std::string; + } + full_name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.full_name) +} +inline void AccountLevelInfo::set_full_name(const char* value) { + set_has_full_name(); + if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + full_name_ = new ::std::string; + } + full_name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountLevelInfo.full_name) +} +inline void AccountLevelInfo::set_full_name(const char* value, size_t size) { + set_has_full_name(); + if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + full_name_ = new ::std::string; + } + full_name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountLevelInfo.full_name) +} +inline ::std::string* AccountLevelInfo::mutable_full_name() { + set_has_full_name(); + if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + full_name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountLevelInfo.full_name) + return full_name_; +} +inline ::std::string* AccountLevelInfo::release_full_name() { + clear_has_full_name(); + if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = full_name_; + full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void AccountLevelInfo::set_allocated_full_name(::std::string* full_name) { + if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete full_name_; + } + if (full_name) { + set_has_full_name(); + full_name_ = full_name; + } else { + clear_has_full_name(); + full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountLevelInfo.full_name) +} + +// optional string battle_tag = 8; +inline bool AccountLevelInfo::has_battle_tag() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void AccountLevelInfo::set_has_battle_tag() { + _has_bits_[0] |= 0x00000020u; +} +inline void AccountLevelInfo::clear_has_battle_tag() { + _has_bits_[0] &= ~0x00000020u; +} +inline void AccountLevelInfo::clear_battle_tag() { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_->clear(); + } + clear_has_battle_tag(); +} +inline const ::std::string& AccountLevelInfo::battle_tag() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.battle_tag) + return *battle_tag_; +} +inline void AccountLevelInfo::set_battle_tag(const ::std::string& value) { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + battle_tag_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.battle_tag) +} +inline void AccountLevelInfo::set_battle_tag(const char* value) { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + battle_tag_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountLevelInfo.battle_tag) +} +inline void AccountLevelInfo::set_battle_tag(const char* value, size_t size) { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + battle_tag_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountLevelInfo.battle_tag) +} +inline ::std::string* AccountLevelInfo::mutable_battle_tag() { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountLevelInfo.battle_tag) + return battle_tag_; +} +inline ::std::string* AccountLevelInfo::release_battle_tag() { + clear_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = battle_tag_; + battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void AccountLevelInfo::set_allocated_battle_tag(::std::string* battle_tag) { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete battle_tag_; + } + if (battle_tag) { + set_has_battle_tag(); + battle_tag_ = battle_tag; + } else { + clear_has_battle_tag(); + battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountLevelInfo.battle_tag) +} + +// optional bool muted = 9; +inline bool AccountLevelInfo::has_muted() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void AccountLevelInfo::set_has_muted() { + _has_bits_[0] |= 0x00000040u; +} +inline void AccountLevelInfo::clear_has_muted() { + _has_bits_[0] &= ~0x00000040u; +} +inline void AccountLevelInfo::clear_muted() { + muted_ = false; + clear_has_muted(); +} +inline bool AccountLevelInfo::muted() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.muted) + return muted_; +} +inline void AccountLevelInfo::set_muted(bool value) { + set_has_muted(); + muted_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.muted) +} + +// optional bool manual_review = 10; +inline bool AccountLevelInfo::has_manual_review() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void AccountLevelInfo::set_has_manual_review() { + _has_bits_[0] |= 0x00000080u; +} +inline void AccountLevelInfo::clear_has_manual_review() { + _has_bits_[0] &= ~0x00000080u; +} +inline void AccountLevelInfo::clear_manual_review() { + manual_review_ = false; + clear_has_manual_review(); +} +inline bool AccountLevelInfo::manual_review() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.manual_review) + return manual_review_; +} +inline void AccountLevelInfo::set_manual_review(bool value) { + set_has_manual_review(); + manual_review_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.manual_review) +} + +// optional bool account_paid_any = 11; +inline bool AccountLevelInfo::has_account_paid_any() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void AccountLevelInfo::set_has_account_paid_any() { + _has_bits_[0] |= 0x00000100u; +} +inline void AccountLevelInfo::clear_has_account_paid_any() { + _has_bits_[0] &= ~0x00000100u; +} +inline void AccountLevelInfo::clear_account_paid_any() { + account_paid_any_ = false; + clear_has_account_paid_any(); +} +inline bool AccountLevelInfo::account_paid_any() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.account_paid_any) + return account_paid_any_; +} +inline void AccountLevelInfo::set_account_paid_any(bool value) { + set_has_account_paid_any(); + account_paid_any_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.account_paid_any) +} + +// optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 12; +inline bool AccountLevelInfo::has_identity_check_status() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +inline void AccountLevelInfo::set_has_identity_check_status() { + _has_bits_[0] |= 0x00000200u; +} +inline void AccountLevelInfo::clear_has_identity_check_status() { + _has_bits_[0] &= ~0x00000200u; +} +inline void AccountLevelInfo::clear_identity_check_status() { + identity_check_status_ = 0; + clear_has_identity_check_status(); +} +inline ::bgs::protocol::account::v1::IdentityVerificationStatus AccountLevelInfo::identity_check_status() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.identity_check_status) + return static_cast< ::bgs::protocol::account::v1::IdentityVerificationStatus >(identity_check_status_); +} +inline void AccountLevelInfo::set_identity_check_status(::bgs::protocol::account::v1::IdentityVerificationStatus value) { + assert(::bgs::protocol::account::v1::IdentityVerificationStatus_IsValid(value)); + set_has_identity_check_status(); + identity_check_status_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.identity_check_status) +} + +// optional string email = 13; +inline bool AccountLevelInfo::has_email() const { + return (_has_bits_[0] & 0x00000400u) != 0; +} +inline void AccountLevelInfo::set_has_email() { + _has_bits_[0] |= 0x00000400u; +} +inline void AccountLevelInfo::clear_has_email() { + _has_bits_[0] &= ~0x00000400u; +} +inline void AccountLevelInfo::clear_email() { + if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_->clear(); + } + clear_has_email(); +} +inline const ::std::string& AccountLevelInfo::email() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.email) + return *email_; +} +inline void AccountLevelInfo::set_email(const ::std::string& value) { + set_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_ = new ::std::string; + } + email_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.email) +} +inline void AccountLevelInfo::set_email(const char* value) { + set_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_ = new ::std::string; + } + email_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountLevelInfo.email) +} +inline void AccountLevelInfo::set_email(const char* value, size_t size) { + set_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_ = new ::std::string; + } + email_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountLevelInfo.email) +} +inline ::std::string* AccountLevelInfo::mutable_email() { + set_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountLevelInfo.email) + return email_; +} +inline ::std::string* AccountLevelInfo::release_email() { + clear_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = email_; + email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void AccountLevelInfo::set_allocated_email(::std::string* email) { + if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete email_; + } + if (email) { + set_has_email(); + email_ = email; + } else { + clear_has_email(); + email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountLevelInfo.email) +} + +// ------------------------------------------------------------------- + +// PrivacyInfo + +// optional bool is_using_rid = 3; +inline bool PrivacyInfo::has_is_using_rid() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void PrivacyInfo::set_has_is_using_rid() { + _has_bits_[0] |= 0x00000001u; +} +inline void PrivacyInfo::clear_has_is_using_rid() { + _has_bits_[0] &= ~0x00000001u; +} +inline void PrivacyInfo::clear_is_using_rid() { + is_using_rid_ = false; + clear_has_is_using_rid(); +} +inline bool PrivacyInfo::is_using_rid() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.PrivacyInfo.is_using_rid) + return is_using_rid_; +} +inline void PrivacyInfo::set_is_using_rid(bool value) { + set_has_is_using_rid(); + is_using_rid_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.PrivacyInfo.is_using_rid) +} + +// optional bool is_real_id_visible_for_view_friends = 4; +inline bool PrivacyInfo::has_is_real_id_visible_for_view_friends() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void PrivacyInfo::set_has_is_real_id_visible_for_view_friends() { + _has_bits_[0] |= 0x00000002u; +} +inline void PrivacyInfo::clear_has_is_real_id_visible_for_view_friends() { + _has_bits_[0] &= ~0x00000002u; +} +inline void PrivacyInfo::clear_is_real_id_visible_for_view_friends() { + is_real_id_visible_for_view_friends_ = false; + clear_has_is_real_id_visible_for_view_friends(); +} +inline bool PrivacyInfo::is_real_id_visible_for_view_friends() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.PrivacyInfo.is_real_id_visible_for_view_friends) + return is_real_id_visible_for_view_friends_; +} +inline void PrivacyInfo::set_is_real_id_visible_for_view_friends(bool value) { + set_has_is_real_id_visible_for_view_friends(); + is_real_id_visible_for_view_friends_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.PrivacyInfo.is_real_id_visible_for_view_friends) +} + +// optional bool is_hidden_from_friend_finder = 5; +inline bool PrivacyInfo::has_is_hidden_from_friend_finder() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void PrivacyInfo::set_has_is_hidden_from_friend_finder() { + _has_bits_[0] |= 0x00000004u; +} +inline void PrivacyInfo::clear_has_is_hidden_from_friend_finder() { + _has_bits_[0] &= ~0x00000004u; +} +inline void PrivacyInfo::clear_is_hidden_from_friend_finder() { + is_hidden_from_friend_finder_ = false; + clear_has_is_hidden_from_friend_finder(); +} +inline bool PrivacyInfo::is_hidden_from_friend_finder() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.PrivacyInfo.is_hidden_from_friend_finder) + return is_hidden_from_friend_finder_; +} +inline void PrivacyInfo::set_is_hidden_from_friend_finder(bool value) { + set_has_is_hidden_from_friend_finder(); + is_hidden_from_friend_finder_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.PrivacyInfo.is_hidden_from_friend_finder) +} + +// optional .bgs.protocol.account.v1.PrivacyInfo.GameInfoPrivacy game_info_privacy = 6 [default = PRIVACY_FRIENDS]; +inline bool PrivacyInfo::has_game_info_privacy() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void PrivacyInfo::set_has_game_info_privacy() { + _has_bits_[0] |= 0x00000008u; +} +inline void PrivacyInfo::clear_has_game_info_privacy() { + _has_bits_[0] &= ~0x00000008u; +} +inline void PrivacyInfo::clear_game_info_privacy() { + game_info_privacy_ = 1; + clear_has_game_info_privacy(); +} +inline ::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy PrivacyInfo::game_info_privacy() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.PrivacyInfo.game_info_privacy) + return static_cast< ::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy >(game_info_privacy_); +} +inline void PrivacyInfo::set_game_info_privacy(::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy value) { + assert(::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy_IsValid(value)); + set_has_game_info_privacy(); + game_info_privacy_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.PrivacyInfo.game_info_privacy) +} + +// ------------------------------------------------------------------- + +// ParentalControlInfo + +// optional string timezone = 3; +inline bool ParentalControlInfo::has_timezone() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ParentalControlInfo::set_has_timezone() { + _has_bits_[0] |= 0x00000001u; +} +inline void ParentalControlInfo::clear_has_timezone() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ParentalControlInfo::clear_timezone() { + if (timezone_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + timezone_->clear(); + } + clear_has_timezone(); +} +inline const ::std::string& ParentalControlInfo::timezone() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ParentalControlInfo.timezone) + return *timezone_; +} +inline void ParentalControlInfo::set_timezone(const ::std::string& value) { + set_has_timezone(); + if (timezone_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + timezone_ = new ::std::string; + } + timezone_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ParentalControlInfo.timezone) +} +inline void ParentalControlInfo::set_timezone(const char* value) { + set_has_timezone(); + if (timezone_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + timezone_ = new ::std::string; + } + timezone_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.ParentalControlInfo.timezone) +} +inline void ParentalControlInfo::set_timezone(const char* value, size_t size) { + set_has_timezone(); + if (timezone_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + timezone_ = new ::std::string; + } + timezone_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.ParentalControlInfo.timezone) +} +inline ::std::string* ParentalControlInfo::mutable_timezone() { + set_has_timezone(); + if (timezone_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + timezone_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.ParentalControlInfo.timezone) + return timezone_; +} +inline ::std::string* ParentalControlInfo::release_timezone() { + clear_has_timezone(); + if (timezone_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = timezone_; + timezone_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ParentalControlInfo::set_allocated_timezone(::std::string* timezone) { + if (timezone_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete timezone_; + } + if (timezone) { + set_has_timezone(); + timezone_ = timezone; + } else { + clear_has_timezone(); + timezone_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.ParentalControlInfo.timezone) +} + +// optional uint32 minutes_per_day = 4; +inline bool ParentalControlInfo::has_minutes_per_day() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ParentalControlInfo::set_has_minutes_per_day() { + _has_bits_[0] |= 0x00000002u; +} +inline void ParentalControlInfo::clear_has_minutes_per_day() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ParentalControlInfo::clear_minutes_per_day() { + minutes_per_day_ = 0u; + clear_has_minutes_per_day(); +} +inline ::google::protobuf::uint32 ParentalControlInfo::minutes_per_day() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ParentalControlInfo.minutes_per_day) + return minutes_per_day_; +} +inline void ParentalControlInfo::set_minutes_per_day(::google::protobuf::uint32 value) { + set_has_minutes_per_day(); + minutes_per_day_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ParentalControlInfo.minutes_per_day) +} + +// optional uint32 minutes_per_week = 5; +inline bool ParentalControlInfo::has_minutes_per_week() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ParentalControlInfo::set_has_minutes_per_week() { + _has_bits_[0] |= 0x00000004u; +} +inline void ParentalControlInfo::clear_has_minutes_per_week() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ParentalControlInfo::clear_minutes_per_week() { + minutes_per_week_ = 0u; + clear_has_minutes_per_week(); +} +inline ::google::protobuf::uint32 ParentalControlInfo::minutes_per_week() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ParentalControlInfo.minutes_per_week) + return minutes_per_week_; +} +inline void ParentalControlInfo::set_minutes_per_week(::google::protobuf::uint32 value) { + set_has_minutes_per_week(); + minutes_per_week_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ParentalControlInfo.minutes_per_week) +} + +// optional bool can_receive_voice = 6; +inline bool ParentalControlInfo::has_can_receive_voice() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void ParentalControlInfo::set_has_can_receive_voice() { + _has_bits_[0] |= 0x00000008u; +} +inline void ParentalControlInfo::clear_has_can_receive_voice() { + _has_bits_[0] &= ~0x00000008u; +} +inline void ParentalControlInfo::clear_can_receive_voice() { + can_receive_voice_ = false; + clear_has_can_receive_voice(); +} +inline bool ParentalControlInfo::can_receive_voice() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ParentalControlInfo.can_receive_voice) + return can_receive_voice_; +} +inline void ParentalControlInfo::set_can_receive_voice(bool value) { + set_has_can_receive_voice(); + can_receive_voice_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ParentalControlInfo.can_receive_voice) +} + +// optional bool can_send_voice = 7; +inline bool ParentalControlInfo::has_can_send_voice() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void ParentalControlInfo::set_has_can_send_voice() { + _has_bits_[0] |= 0x00000010u; +} +inline void ParentalControlInfo::clear_has_can_send_voice() { + _has_bits_[0] &= ~0x00000010u; +} +inline void ParentalControlInfo::clear_can_send_voice() { + can_send_voice_ = false; + clear_has_can_send_voice(); +} +inline bool ParentalControlInfo::can_send_voice() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ParentalControlInfo.can_send_voice) + return can_send_voice_; +} +inline void ParentalControlInfo::set_can_send_voice(bool value) { + set_has_can_send_voice(); + can_send_voice_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ParentalControlInfo.can_send_voice) +} + +// repeated bool play_schedule = 8; +inline int ParentalControlInfo::play_schedule_size() const { + return play_schedule_.size(); +} +inline void ParentalControlInfo::clear_play_schedule() { + play_schedule_.Clear(); +} +inline bool ParentalControlInfo::play_schedule(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ParentalControlInfo.play_schedule) + return play_schedule_.Get(index); +} +inline void ParentalControlInfo::set_play_schedule(int index, bool value) { + play_schedule_.Set(index, value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ParentalControlInfo.play_schedule) +} +inline void ParentalControlInfo::add_play_schedule(bool value) { + play_schedule_.Add(value); + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.ParentalControlInfo.play_schedule) +} +inline const ::google::protobuf::RepeatedField< bool >& +ParentalControlInfo::play_schedule() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.ParentalControlInfo.play_schedule) + return play_schedule_; +} +inline ::google::protobuf::RepeatedField< bool >* +ParentalControlInfo::mutable_play_schedule() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.ParentalControlInfo.play_schedule) + return &play_schedule_; +} + +// ------------------------------------------------------------------- + +// GameLevelInfo + +// optional bool is_trial = 4; +inline bool GameLevelInfo::has_is_trial() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GameLevelInfo::set_has_is_trial() { + _has_bits_[0] |= 0x00000001u; +} +inline void GameLevelInfo::clear_has_is_trial() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GameLevelInfo::clear_is_trial() { + is_trial_ = false; + clear_has_is_trial(); +} +inline bool GameLevelInfo::is_trial() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameLevelInfo.is_trial) + return is_trial_; +} +inline void GameLevelInfo::set_is_trial(bool value) { + set_has_is_trial(); + is_trial_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameLevelInfo.is_trial) +} + +// optional bool is_lifetime = 5; +inline bool GameLevelInfo::has_is_lifetime() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GameLevelInfo::set_has_is_lifetime() { + _has_bits_[0] |= 0x00000002u; +} +inline void GameLevelInfo::clear_has_is_lifetime() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GameLevelInfo::clear_is_lifetime() { + is_lifetime_ = false; + clear_has_is_lifetime(); +} +inline bool GameLevelInfo::is_lifetime() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameLevelInfo.is_lifetime) + return is_lifetime_; +} +inline void GameLevelInfo::set_is_lifetime(bool value) { + set_has_is_lifetime(); + is_lifetime_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameLevelInfo.is_lifetime) +} + +// optional bool is_restricted = 6; +inline bool GameLevelInfo::has_is_restricted() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GameLevelInfo::set_has_is_restricted() { + _has_bits_[0] |= 0x00000004u; +} +inline void GameLevelInfo::clear_has_is_restricted() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GameLevelInfo::clear_is_restricted() { + is_restricted_ = false; + clear_has_is_restricted(); +} +inline bool GameLevelInfo::is_restricted() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameLevelInfo.is_restricted) + return is_restricted_; +} +inline void GameLevelInfo::set_is_restricted(bool value) { + set_has_is_restricted(); + is_restricted_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameLevelInfo.is_restricted) +} + +// optional bool is_beta = 7; +inline bool GameLevelInfo::has_is_beta() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void GameLevelInfo::set_has_is_beta() { + _has_bits_[0] |= 0x00000008u; +} +inline void GameLevelInfo::clear_has_is_beta() { + _has_bits_[0] &= ~0x00000008u; +} +inline void GameLevelInfo::clear_is_beta() { + is_beta_ = false; + clear_has_is_beta(); +} +inline bool GameLevelInfo::is_beta() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameLevelInfo.is_beta) + return is_beta_; +} +inline void GameLevelInfo::set_is_beta(bool value) { + set_has_is_beta(); + is_beta_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameLevelInfo.is_beta) +} + +// optional string name = 8; +inline bool GameLevelInfo::has_name() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void GameLevelInfo::set_has_name() { + _has_bits_[0] |= 0x00000010u; +} +inline void GameLevelInfo::clear_has_name() { + _has_bits_[0] &= ~0x00000010u; +} +inline void GameLevelInfo::clear_name() { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& GameLevelInfo::name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameLevelInfo.name) + return *name_; +} +inline void GameLevelInfo::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameLevelInfo.name) +} +inline void GameLevelInfo::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GameLevelInfo.name) +} +inline void GameLevelInfo::set_name(const char* value, size_t size) { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GameLevelInfo.name) +} +inline ::std::string* GameLevelInfo::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameLevelInfo.name) + return name_; +} +inline ::std::string* GameLevelInfo::release_name() { + clear_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = name_; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void GameLevelInfo::set_allocated_name(::std::string* name) { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete name_; + } + if (name) { + set_has_name(); + name_ = name; + } else { + clear_has_name(); + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameLevelInfo.name) +} + +// optional fixed32 program = 9; +inline bool GameLevelInfo::has_program() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void GameLevelInfo::set_has_program() { + _has_bits_[0] |= 0x00000020u; +} +inline void GameLevelInfo::clear_has_program() { + _has_bits_[0] &= ~0x00000020u; +} +inline void GameLevelInfo::clear_program() { + program_ = 0u; + clear_has_program(); +} +inline ::google::protobuf::uint32 GameLevelInfo::program() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameLevelInfo.program) + return program_; +} +inline void GameLevelInfo::set_program(::google::protobuf::uint32 value) { + set_has_program(); + program_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameLevelInfo.program) +} + +// repeated .bgs.protocol.account.v1.AccountLicense licenses = 10; +inline int GameLevelInfo::licenses_size() const { + return licenses_.size(); +} +inline void GameLevelInfo::clear_licenses() { + licenses_.Clear(); +} +inline const ::bgs::protocol::account::v1::AccountLicense& GameLevelInfo::licenses(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameLevelInfo.licenses) + return licenses_.Get(index); +} +inline ::bgs::protocol::account::v1::AccountLicense* GameLevelInfo::mutable_licenses(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameLevelInfo.licenses) + return licenses_.Mutable(index); +} +inline ::bgs::protocol::account::v1::AccountLicense* GameLevelInfo::add_licenses() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GameLevelInfo.licenses) + return licenses_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >& +GameLevelInfo::licenses() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GameLevelInfo.licenses) + return licenses_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >* +GameLevelInfo::mutable_licenses() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GameLevelInfo.licenses) + return &licenses_; +} + +// optional uint32 realm_permissions = 11; +inline bool GameLevelInfo::has_realm_permissions() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void GameLevelInfo::set_has_realm_permissions() { + _has_bits_[0] |= 0x00000080u; +} +inline void GameLevelInfo::clear_has_realm_permissions() { + _has_bits_[0] &= ~0x00000080u; +} +inline void GameLevelInfo::clear_realm_permissions() { + realm_permissions_ = 0u; + clear_has_realm_permissions(); +} +inline ::google::protobuf::uint32 GameLevelInfo::realm_permissions() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameLevelInfo.realm_permissions) + return realm_permissions_; +} +inline void GameLevelInfo::set_realm_permissions(::google::protobuf::uint32 value) { + set_has_realm_permissions(); + realm_permissions_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameLevelInfo.realm_permissions) +} + +// ------------------------------------------------------------------- + +// GameTimeInfo + +// optional bool is_unlimited_play_time = 3; +inline bool GameTimeInfo::has_is_unlimited_play_time() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GameTimeInfo::set_has_is_unlimited_play_time() { + _has_bits_[0] |= 0x00000001u; +} +inline void GameTimeInfo::clear_has_is_unlimited_play_time() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GameTimeInfo::clear_is_unlimited_play_time() { + is_unlimited_play_time_ = false; + clear_has_is_unlimited_play_time(); +} +inline bool GameTimeInfo::is_unlimited_play_time() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameTimeInfo.is_unlimited_play_time) + return is_unlimited_play_time_; +} +inline void GameTimeInfo::set_is_unlimited_play_time(bool value) { + set_has_is_unlimited_play_time(); + is_unlimited_play_time_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameTimeInfo.is_unlimited_play_time) +} + +// optional uint64 play_time_expires = 5; +inline bool GameTimeInfo::has_play_time_expires() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GameTimeInfo::set_has_play_time_expires() { + _has_bits_[0] |= 0x00000002u; +} +inline void GameTimeInfo::clear_has_play_time_expires() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GameTimeInfo::clear_play_time_expires() { + play_time_expires_ = GOOGLE_ULONGLONG(0); + clear_has_play_time_expires(); +} +inline ::google::protobuf::uint64 GameTimeInfo::play_time_expires() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameTimeInfo.play_time_expires) + return play_time_expires_; +} +inline void GameTimeInfo::set_play_time_expires(::google::protobuf::uint64 value) { + set_has_play_time_expires(); + play_time_expires_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameTimeInfo.play_time_expires) +} + +// optional bool is_subscription = 6; +inline bool GameTimeInfo::has_is_subscription() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GameTimeInfo::set_has_is_subscription() { + _has_bits_[0] |= 0x00000004u; +} +inline void GameTimeInfo::clear_has_is_subscription() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GameTimeInfo::clear_is_subscription() { + is_subscription_ = false; + clear_has_is_subscription(); +} +inline bool GameTimeInfo::is_subscription() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameTimeInfo.is_subscription) + return is_subscription_; +} +inline void GameTimeInfo::set_is_subscription(bool value) { + set_has_is_subscription(); + is_subscription_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameTimeInfo.is_subscription) +} + +// optional bool is_recurring_subscription = 7; +inline bool GameTimeInfo::has_is_recurring_subscription() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void GameTimeInfo::set_has_is_recurring_subscription() { + _has_bits_[0] |= 0x00000008u; +} +inline void GameTimeInfo::clear_has_is_recurring_subscription() { + _has_bits_[0] &= ~0x00000008u; +} +inline void GameTimeInfo::clear_is_recurring_subscription() { + is_recurring_subscription_ = false; + clear_has_is_recurring_subscription(); +} +inline bool GameTimeInfo::is_recurring_subscription() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameTimeInfo.is_recurring_subscription) + return is_recurring_subscription_; +} +inline void GameTimeInfo::set_is_recurring_subscription(bool value) { + set_has_is_recurring_subscription(); + is_recurring_subscription_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameTimeInfo.is_recurring_subscription) +} + +// ------------------------------------------------------------------- + +// GameTimeRemainingInfo + +// optional uint32 minutes_remaining = 1; +inline bool GameTimeRemainingInfo::has_minutes_remaining() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GameTimeRemainingInfo::set_has_minutes_remaining() { + _has_bits_[0] |= 0x00000001u; +} +inline void GameTimeRemainingInfo::clear_has_minutes_remaining() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GameTimeRemainingInfo::clear_minutes_remaining() { + minutes_remaining_ = 0u; + clear_has_minutes_remaining(); +} +inline ::google::protobuf::uint32 GameTimeRemainingInfo::minutes_remaining() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameTimeRemainingInfo.minutes_remaining) + return minutes_remaining_; +} +inline void GameTimeRemainingInfo::set_minutes_remaining(::google::protobuf::uint32 value) { + set_has_minutes_remaining(); + minutes_remaining_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameTimeRemainingInfo.minutes_remaining) +} + +// optional uint32 parental_daily_minutes_remaining = 2; +inline bool GameTimeRemainingInfo::has_parental_daily_minutes_remaining() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GameTimeRemainingInfo::set_has_parental_daily_minutes_remaining() { + _has_bits_[0] |= 0x00000002u; +} +inline void GameTimeRemainingInfo::clear_has_parental_daily_minutes_remaining() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GameTimeRemainingInfo::clear_parental_daily_minutes_remaining() { + parental_daily_minutes_remaining_ = 0u; + clear_has_parental_daily_minutes_remaining(); +} +inline ::google::protobuf::uint32 GameTimeRemainingInfo::parental_daily_minutes_remaining() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameTimeRemainingInfo.parental_daily_minutes_remaining) + return parental_daily_minutes_remaining_; +} +inline void GameTimeRemainingInfo::set_parental_daily_minutes_remaining(::google::protobuf::uint32 value) { + set_has_parental_daily_minutes_remaining(); + parental_daily_minutes_remaining_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameTimeRemainingInfo.parental_daily_minutes_remaining) +} + +// optional uint32 parental_weekly_minutes_remaining = 3; +inline bool GameTimeRemainingInfo::has_parental_weekly_minutes_remaining() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GameTimeRemainingInfo::set_has_parental_weekly_minutes_remaining() { + _has_bits_[0] |= 0x00000004u; +} +inline void GameTimeRemainingInfo::clear_has_parental_weekly_minutes_remaining() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GameTimeRemainingInfo::clear_parental_weekly_minutes_remaining() { + parental_weekly_minutes_remaining_ = 0u; + clear_has_parental_weekly_minutes_remaining(); +} +inline ::google::protobuf::uint32 GameTimeRemainingInfo::parental_weekly_minutes_remaining() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameTimeRemainingInfo.parental_weekly_minutes_remaining) + return parental_weekly_minutes_remaining_; +} +inline void GameTimeRemainingInfo::set_parental_weekly_minutes_remaining(::google::protobuf::uint32 value) { + set_has_parental_weekly_minutes_remaining(); + parental_weekly_minutes_remaining_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameTimeRemainingInfo.parental_weekly_minutes_remaining) +} + +// optional uint32 seconds_remaining_until_kick = 4; +inline bool GameTimeRemainingInfo::has_seconds_remaining_until_kick() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void GameTimeRemainingInfo::set_has_seconds_remaining_until_kick() { + _has_bits_[0] |= 0x00000008u; +} +inline void GameTimeRemainingInfo::clear_has_seconds_remaining_until_kick() { + _has_bits_[0] &= ~0x00000008u; +} +inline void GameTimeRemainingInfo::clear_seconds_remaining_until_kick() { + seconds_remaining_until_kick_ = 0u; + clear_has_seconds_remaining_until_kick(); +} +inline ::google::protobuf::uint32 GameTimeRemainingInfo::seconds_remaining_until_kick() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameTimeRemainingInfo.seconds_remaining_until_kick) + return seconds_remaining_until_kick_; +} +inline void GameTimeRemainingInfo::set_seconds_remaining_until_kick(::google::protobuf::uint32 value) { + set_has_seconds_remaining_until_kick(); + seconds_remaining_until_kick_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameTimeRemainingInfo.seconds_remaining_until_kick) +} + +// ------------------------------------------------------------------- + +// GameStatus + +// optional bool is_suspended = 4; +inline bool GameStatus::has_is_suspended() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GameStatus::set_has_is_suspended() { + _has_bits_[0] |= 0x00000001u; +} +inline void GameStatus::clear_has_is_suspended() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GameStatus::clear_is_suspended() { + is_suspended_ = false; + clear_has_is_suspended(); +} +inline bool GameStatus::is_suspended() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameStatus.is_suspended) + return is_suspended_; +} +inline void GameStatus::set_is_suspended(bool value) { + set_has_is_suspended(); + is_suspended_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameStatus.is_suspended) +} + +// optional bool is_banned = 5; +inline bool GameStatus::has_is_banned() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GameStatus::set_has_is_banned() { + _has_bits_[0] |= 0x00000002u; +} +inline void GameStatus::clear_has_is_banned() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GameStatus::clear_is_banned() { + is_banned_ = false; + clear_has_is_banned(); +} +inline bool GameStatus::is_banned() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameStatus.is_banned) + return is_banned_; +} +inline void GameStatus::set_is_banned(bool value) { + set_has_is_banned(); + is_banned_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameStatus.is_banned) +} + +// optional uint64 suspension_expires = 6; +inline bool GameStatus::has_suspension_expires() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GameStatus::set_has_suspension_expires() { + _has_bits_[0] |= 0x00000004u; +} +inline void GameStatus::clear_has_suspension_expires() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GameStatus::clear_suspension_expires() { + suspension_expires_ = GOOGLE_ULONGLONG(0); + clear_has_suspension_expires(); +} +inline ::google::protobuf::uint64 GameStatus::suspension_expires() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameStatus.suspension_expires) + return suspension_expires_; +} +inline void GameStatus::set_suspension_expires(::google::protobuf::uint64 value) { + set_has_suspension_expires(); + suspension_expires_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameStatus.suspension_expires) +} + +// optional fixed32 program = 7; +inline bool GameStatus::has_program() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void GameStatus::set_has_program() { + _has_bits_[0] |= 0x00000008u; +} +inline void GameStatus::clear_has_program() { + _has_bits_[0] &= ~0x00000008u; +} +inline void GameStatus::clear_program() { + program_ = 0u; + clear_has_program(); +} +inline ::google::protobuf::uint32 GameStatus::program() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameStatus.program) + return program_; +} +inline void GameStatus::set_program(::google::protobuf::uint32 value) { + set_has_program(); + program_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameStatus.program) +} + +// optional bool is_locked = 8; +inline bool GameStatus::has_is_locked() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void GameStatus::set_has_is_locked() { + _has_bits_[0] |= 0x00000010u; +} +inline void GameStatus::clear_has_is_locked() { + _has_bits_[0] &= ~0x00000010u; +} +inline void GameStatus::clear_is_locked() { + is_locked_ = false; + clear_has_is_locked(); +} +inline bool GameStatus::is_locked() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameStatus.is_locked) + return is_locked_; +} +inline void GameStatus::set_is_locked(bool value) { + set_has_is_locked(); + is_locked_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameStatus.is_locked) +} + +// optional bool is_bam_unlockable = 9; +inline bool GameStatus::has_is_bam_unlockable() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void GameStatus::set_has_is_bam_unlockable() { + _has_bits_[0] |= 0x00000020u; +} +inline void GameStatus::clear_has_is_bam_unlockable() { + _has_bits_[0] &= ~0x00000020u; +} +inline void GameStatus::clear_is_bam_unlockable() { + is_bam_unlockable_ = false; + clear_has_is_bam_unlockable(); +} +inline bool GameStatus::is_bam_unlockable() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameStatus.is_bam_unlockable) + return is_bam_unlockable_; +} +inline void GameStatus::set_is_bam_unlockable(bool value) { + set_has_is_bam_unlockable(); + is_bam_unlockable_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameStatus.is_bam_unlockable) +} + +// ------------------------------------------------------------------- + +// RAFInfo + +// optional bytes raf_info = 1; +inline bool RAFInfo::has_raf_info() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void RAFInfo::set_has_raf_info() { + _has_bits_[0] |= 0x00000001u; +} +inline void RAFInfo::clear_has_raf_info() { + _has_bits_[0] &= ~0x00000001u; +} +inline void RAFInfo::clear_raf_info() { + if (raf_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + raf_info_->clear(); + } + clear_has_raf_info(); +} +inline const ::std::string& RAFInfo::raf_info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.RAFInfo.raf_info) + return *raf_info_; +} +inline void RAFInfo::set_raf_info(const ::std::string& value) { + set_has_raf_info(); + if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + raf_info_ = new ::std::string; + } + raf_info_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.RAFInfo.raf_info) +} +inline void RAFInfo::set_raf_info(const char* value) { + set_has_raf_info(); + if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + raf_info_ = new ::std::string; + } + raf_info_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.RAFInfo.raf_info) +} +inline void RAFInfo::set_raf_info(const void* value, size_t size) { + set_has_raf_info(); + if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + raf_info_ = new ::std::string; + } + raf_info_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.RAFInfo.raf_info) +} +inline ::std::string* RAFInfo::mutable_raf_info() { + set_has_raf_info(); + if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + raf_info_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.RAFInfo.raf_info) + return raf_info_; +} +inline ::std::string* RAFInfo::release_raf_info() { + clear_has_raf_info(); + if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = raf_info_; + raf_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void RAFInfo::set_allocated_raf_info(::std::string* raf_info) { + if (raf_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete raf_info_; + } + if (raf_info) { + set_has_raf_info(); + raf_info_ = raf_info; + } else { + clear_has_raf_info(); + raf_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.RAFInfo.raf_info) +} + +// ------------------------------------------------------------------- + +// GameSessionInfo + +// optional uint32 start_time = 3 [deprecated = true]; +inline bool GameSessionInfo::has_start_time() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GameSessionInfo::set_has_start_time() { + _has_bits_[0] |= 0x00000001u; +} +inline void GameSessionInfo::clear_has_start_time() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GameSessionInfo::clear_start_time() { + start_time_ = 0u; + clear_has_start_time(); +} +inline ::google::protobuf::uint32 GameSessionInfo::start_time() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameSessionInfo.start_time) + return start_time_; +} +inline void GameSessionInfo::set_start_time(::google::protobuf::uint32 value) { + set_has_start_time(); + start_time_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameSessionInfo.start_time) +} + +// optional .bgs.protocol.account.v1.GameSessionLocation location = 4; +inline bool GameSessionInfo::has_location() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GameSessionInfo::set_has_location() { + _has_bits_[0] |= 0x00000002u; +} +inline void GameSessionInfo::clear_has_location() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GameSessionInfo::clear_location() { + if (location_ != NULL) location_->::bgs::protocol::account::v1::GameSessionLocation::Clear(); + clear_has_location(); +} +inline const ::bgs::protocol::account::v1::GameSessionLocation& GameSessionInfo::location() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameSessionInfo.location) + return location_ != NULL ? *location_ : *default_instance_->location_; +} +inline ::bgs::protocol::account::v1::GameSessionLocation* GameSessionInfo::mutable_location() { + set_has_location(); + if (location_ == NULL) location_ = new ::bgs::protocol::account::v1::GameSessionLocation; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameSessionInfo.location) + return location_; +} +inline ::bgs::protocol::account::v1::GameSessionLocation* GameSessionInfo::release_location() { + clear_has_location(); + ::bgs::protocol::account::v1::GameSessionLocation* temp = location_; + location_ = NULL; + return temp; +} +inline void GameSessionInfo::set_allocated_location(::bgs::protocol::account::v1::GameSessionLocation* location) { + delete location_; + location_ = location; + if (location) { + set_has_location(); + } else { + clear_has_location(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameSessionInfo.location) +} + +// optional bool has_benefactor = 5; +inline bool GameSessionInfo::has_has_benefactor() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GameSessionInfo::set_has_has_benefactor() { + _has_bits_[0] |= 0x00000004u; +} +inline void GameSessionInfo::clear_has_has_benefactor() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GameSessionInfo::clear_has_benefactor() { + has_benefactor_ = false; + clear_has_has_benefactor(); +} +inline bool GameSessionInfo::has_benefactor() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameSessionInfo.has_benefactor) + return has_benefactor_; +} +inline void GameSessionInfo::set_has_benefactor(bool value) { + set_has_has_benefactor(); + has_benefactor_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameSessionInfo.has_benefactor) +} + +// optional bool is_using_igr = 6; +inline bool GameSessionInfo::has_is_using_igr() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void GameSessionInfo::set_has_is_using_igr() { + _has_bits_[0] |= 0x00000008u; +} +inline void GameSessionInfo::clear_has_is_using_igr() { + _has_bits_[0] &= ~0x00000008u; +} +inline void GameSessionInfo::clear_is_using_igr() { + is_using_igr_ = false; + clear_has_is_using_igr(); +} +inline bool GameSessionInfo::is_using_igr() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameSessionInfo.is_using_igr) + return is_using_igr_; +} +inline void GameSessionInfo::set_is_using_igr(bool value) { + set_has_is_using_igr(); + is_using_igr_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameSessionInfo.is_using_igr) +} + +// optional bool parental_controls_active = 7; +inline bool GameSessionInfo::has_parental_controls_active() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void GameSessionInfo::set_has_parental_controls_active() { + _has_bits_[0] |= 0x00000010u; +} +inline void GameSessionInfo::clear_has_parental_controls_active() { + _has_bits_[0] &= ~0x00000010u; +} +inline void GameSessionInfo::clear_parental_controls_active() { + parental_controls_active_ = false; + clear_has_parental_controls_active(); +} +inline bool GameSessionInfo::parental_controls_active() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameSessionInfo.parental_controls_active) + return parental_controls_active_; +} +inline void GameSessionInfo::set_parental_controls_active(bool value) { + set_has_parental_controls_active(); + parental_controls_active_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameSessionInfo.parental_controls_active) +} + +// optional uint64 start_time_sec = 8; +inline bool GameSessionInfo::has_start_time_sec() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void GameSessionInfo::set_has_start_time_sec() { + _has_bits_[0] |= 0x00000020u; +} +inline void GameSessionInfo::clear_has_start_time_sec() { + _has_bits_[0] &= ~0x00000020u; +} +inline void GameSessionInfo::clear_start_time_sec() { + start_time_sec_ = GOOGLE_ULONGLONG(0); + clear_has_start_time_sec(); +} +inline ::google::protobuf::uint64 GameSessionInfo::start_time_sec() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameSessionInfo.start_time_sec) + return start_time_sec_; +} +inline void GameSessionInfo::set_start_time_sec(::google::protobuf::uint64 value) { + set_has_start_time_sec(); + start_time_sec_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameSessionInfo.start_time_sec) +} + +// ------------------------------------------------------------------- + +// GameSessionUpdateInfo + +// optional .bgs.protocol.account.v1.CAIS cais = 8; +inline bool GameSessionUpdateInfo::has_cais() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GameSessionUpdateInfo::set_has_cais() { + _has_bits_[0] |= 0x00000001u; +} +inline void GameSessionUpdateInfo::clear_has_cais() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GameSessionUpdateInfo::clear_cais() { + if (cais_ != NULL) cais_->::bgs::protocol::account::v1::CAIS::Clear(); + clear_has_cais(); +} +inline const ::bgs::protocol::account::v1::CAIS& GameSessionUpdateInfo::cais() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameSessionUpdateInfo.cais) + return cais_ != NULL ? *cais_ : *default_instance_->cais_; +} +inline ::bgs::protocol::account::v1::CAIS* GameSessionUpdateInfo::mutable_cais() { + set_has_cais(); + if (cais_ == NULL) cais_ = new ::bgs::protocol::account::v1::CAIS; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameSessionUpdateInfo.cais) + return cais_; +} +inline ::bgs::protocol::account::v1::CAIS* GameSessionUpdateInfo::release_cais() { + clear_has_cais(); + ::bgs::protocol::account::v1::CAIS* temp = cais_; + cais_ = NULL; + return temp; +} +inline void GameSessionUpdateInfo::set_allocated_cais(::bgs::protocol::account::v1::CAIS* cais) { + delete cais_; + cais_ = cais; + if (cais) { + set_has_cais(); + } else { + clear_has_cais(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameSessionUpdateInfo.cais) +} + +// ------------------------------------------------------------------- + +// GameSessionLocation + +// optional string ip_address = 1; +inline bool GameSessionLocation::has_ip_address() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GameSessionLocation::set_has_ip_address() { + _has_bits_[0] |= 0x00000001u; +} +inline void GameSessionLocation::clear_has_ip_address() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GameSessionLocation::clear_ip_address() { + if (ip_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + ip_address_->clear(); + } + clear_has_ip_address(); +} +inline const ::std::string& GameSessionLocation::ip_address() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameSessionLocation.ip_address) + return *ip_address_; +} +inline void GameSessionLocation::set_ip_address(const ::std::string& value) { + set_has_ip_address(); + if (ip_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + ip_address_ = new ::std::string; + } + ip_address_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameSessionLocation.ip_address) +} +inline void GameSessionLocation::set_ip_address(const char* value) { + set_has_ip_address(); + if (ip_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + ip_address_ = new ::std::string; + } + ip_address_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GameSessionLocation.ip_address) +} +inline void GameSessionLocation::set_ip_address(const char* value, size_t size) { + set_has_ip_address(); + if (ip_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + ip_address_ = new ::std::string; + } + ip_address_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GameSessionLocation.ip_address) +} +inline ::std::string* GameSessionLocation::mutable_ip_address() { + set_has_ip_address(); + if (ip_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + ip_address_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameSessionLocation.ip_address) + return ip_address_; +} +inline ::std::string* GameSessionLocation::release_ip_address() { + clear_has_ip_address(); + if (ip_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = ip_address_; + ip_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void GameSessionLocation::set_allocated_ip_address(::std::string* ip_address) { + if (ip_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete ip_address_; + } + if (ip_address) { + set_has_ip_address(); + ip_address_ = ip_address; + } else { + clear_has_ip_address(); + ip_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameSessionLocation.ip_address) +} + +// optional uint32 country = 2; +inline bool GameSessionLocation::has_country() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GameSessionLocation::set_has_country() { + _has_bits_[0] |= 0x00000002u; +} +inline void GameSessionLocation::clear_has_country() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GameSessionLocation::clear_country() { + country_ = 0u; + clear_has_country(); +} +inline ::google::protobuf::uint32 GameSessionLocation::country() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameSessionLocation.country) + return country_; +} +inline void GameSessionLocation::set_country(::google::protobuf::uint32 value) { + set_has_country(); + country_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameSessionLocation.country) +} + +// optional string city = 3; +inline bool GameSessionLocation::has_city() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GameSessionLocation::set_has_city() { + _has_bits_[0] |= 0x00000004u; +} +inline void GameSessionLocation::clear_has_city() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GameSessionLocation::clear_city() { + if (city_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + city_->clear(); + } + clear_has_city(); +} +inline const ::std::string& GameSessionLocation::city() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameSessionLocation.city) + return *city_; +} +inline void GameSessionLocation::set_city(const ::std::string& value) { + set_has_city(); + if (city_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + city_ = new ::std::string; + } + city_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameSessionLocation.city) +} +inline void GameSessionLocation::set_city(const char* value) { + set_has_city(); + if (city_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + city_ = new ::std::string; + } + city_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GameSessionLocation.city) +} +inline void GameSessionLocation::set_city(const char* value, size_t size) { + set_has_city(); + if (city_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + city_ = new ::std::string; + } + city_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GameSessionLocation.city) +} +inline ::std::string* GameSessionLocation::mutable_city() { + set_has_city(); + if (city_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + city_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameSessionLocation.city) + return city_; +} +inline ::std::string* GameSessionLocation::release_city() { + clear_has_city(); + if (city_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = city_; + city_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void GameSessionLocation::set_allocated_city(::std::string* city) { + if (city_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete city_; + } + if (city) { + set_has_city(); + city_ = city; + } else { + clear_has_city(); + city_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameSessionLocation.city) +} + +// ------------------------------------------------------------------- + +// CAIS + +// optional uint32 played_minutes = 1; +inline bool CAIS::has_played_minutes() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void CAIS::set_has_played_minutes() { + _has_bits_[0] |= 0x00000001u; +} +inline void CAIS::clear_has_played_minutes() { + _has_bits_[0] &= ~0x00000001u; +} +inline void CAIS::clear_played_minutes() { + played_minutes_ = 0u; + clear_has_played_minutes(); +} +inline ::google::protobuf::uint32 CAIS::played_minutes() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CAIS.played_minutes) + return played_minutes_; +} +inline void CAIS::set_played_minutes(::google::protobuf::uint32 value) { + set_has_played_minutes(); + played_minutes_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.CAIS.played_minutes) +} + +// optional uint32 rested_minutes = 2; +inline bool CAIS::has_rested_minutes() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void CAIS::set_has_rested_minutes() { + _has_bits_[0] |= 0x00000002u; +} +inline void CAIS::clear_has_rested_minutes() { + _has_bits_[0] &= ~0x00000002u; +} +inline void CAIS::clear_rested_minutes() { + rested_minutes_ = 0u; + clear_has_rested_minutes(); +} +inline ::google::protobuf::uint32 CAIS::rested_minutes() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CAIS.rested_minutes) + return rested_minutes_; +} +inline void CAIS::set_rested_minutes(::google::protobuf::uint32 value) { + set_has_rested_minutes(); + rested_minutes_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.CAIS.rested_minutes) +} + +// optional uint64 last_heard_time = 3; +inline bool CAIS::has_last_heard_time() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void CAIS::set_has_last_heard_time() { + _has_bits_[0] |= 0x00000004u; +} +inline void CAIS::clear_has_last_heard_time() { + _has_bits_[0] &= ~0x00000004u; +} +inline void CAIS::clear_last_heard_time() { + last_heard_time_ = GOOGLE_ULONGLONG(0); + clear_has_last_heard_time(); +} +inline ::google::protobuf::uint64 CAIS::last_heard_time() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CAIS.last_heard_time) + return last_heard_time_; +} +inline void CAIS::set_last_heard_time(::google::protobuf::uint64 value) { + set_has_last_heard_time(); + last_heard_time_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.CAIS.last_heard_time) +} + +// ------------------------------------------------------------------- + +// GameAccountList + +// optional uint32 region = 3; +inline bool GameAccountList::has_region() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GameAccountList::set_has_region() { + _has_bits_[0] |= 0x00000001u; +} +inline void GameAccountList::clear_has_region() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GameAccountList::clear_region() { + region_ = 0u; + clear_has_region(); +} +inline ::google::protobuf::uint32 GameAccountList::region() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountList.region) + return region_; +} +inline void GameAccountList::set_region(::google::protobuf::uint32 value) { + set_has_region(); + region_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountList.region) +} + +// repeated .bgs.protocol.account.v1.GameAccountHandle handle = 4; +inline int GameAccountList::handle_size() const { + return handle_.size(); +} +inline void GameAccountList::clear_handle() { + handle_.Clear(); +} +inline const ::bgs::protocol::account::v1::GameAccountHandle& GameAccountList::handle(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountList.handle) + return handle_.Get(index); +} +inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountList::mutable_handle(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountList.handle) + return handle_.Mutable(index); +} +inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountList::add_handle() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GameAccountList.handle) + return handle_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle >& +GameAccountList::handle() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GameAccountList.handle) + return handle_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle >* +GameAccountList::mutable_handle() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GameAccountList.handle) + return &handle_; +} + +// ------------------------------------------------------------------- + +// AccountState + +// optional .bgs.protocol.account.v1.AccountLevelInfo account_level_info = 1; +inline bool AccountState::has_account_level_info() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AccountState::set_has_account_level_info() { + _has_bits_[0] |= 0x00000001u; +} +inline void AccountState::clear_has_account_level_info() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AccountState::clear_account_level_info() { + if (account_level_info_ != NULL) account_level_info_->::bgs::protocol::account::v1::AccountLevelInfo::Clear(); + clear_has_account_level_info(); +} +inline const ::bgs::protocol::account::v1::AccountLevelInfo& AccountState::account_level_info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountState.account_level_info) + return account_level_info_ != NULL ? *account_level_info_ : *default_instance_->account_level_info_; +} +inline ::bgs::protocol::account::v1::AccountLevelInfo* AccountState::mutable_account_level_info() { + set_has_account_level_info(); + if (account_level_info_ == NULL) account_level_info_ = new ::bgs::protocol::account::v1::AccountLevelInfo; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountState.account_level_info) + return account_level_info_; +} +inline ::bgs::protocol::account::v1::AccountLevelInfo* AccountState::release_account_level_info() { + clear_has_account_level_info(); + ::bgs::protocol::account::v1::AccountLevelInfo* temp = account_level_info_; + account_level_info_ = NULL; + return temp; +} +inline void AccountState::set_allocated_account_level_info(::bgs::protocol::account::v1::AccountLevelInfo* account_level_info) { + delete account_level_info_; + account_level_info_ = account_level_info; + if (account_level_info) { + set_has_account_level_info(); + } else { + clear_has_account_level_info(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountState.account_level_info) +} + +// optional .bgs.protocol.account.v1.PrivacyInfo privacy_info = 2; +inline bool AccountState::has_privacy_info() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void AccountState::set_has_privacy_info() { + _has_bits_[0] |= 0x00000002u; +} +inline void AccountState::clear_has_privacy_info() { + _has_bits_[0] &= ~0x00000002u; +} +inline void AccountState::clear_privacy_info() { + if (privacy_info_ != NULL) privacy_info_->::bgs::protocol::account::v1::PrivacyInfo::Clear(); + clear_has_privacy_info(); +} +inline const ::bgs::protocol::account::v1::PrivacyInfo& AccountState::privacy_info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountState.privacy_info) + return privacy_info_ != NULL ? *privacy_info_ : *default_instance_->privacy_info_; +} +inline ::bgs::protocol::account::v1::PrivacyInfo* AccountState::mutable_privacy_info() { + set_has_privacy_info(); + if (privacy_info_ == NULL) privacy_info_ = new ::bgs::protocol::account::v1::PrivacyInfo; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountState.privacy_info) + return privacy_info_; +} +inline ::bgs::protocol::account::v1::PrivacyInfo* AccountState::release_privacy_info() { + clear_has_privacy_info(); + ::bgs::protocol::account::v1::PrivacyInfo* temp = privacy_info_; + privacy_info_ = NULL; + return temp; +} +inline void AccountState::set_allocated_privacy_info(::bgs::protocol::account::v1::PrivacyInfo* privacy_info) { + delete privacy_info_; + privacy_info_ = privacy_info; + if (privacy_info) { + set_has_privacy_info(); + } else { + clear_has_privacy_info(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountState.privacy_info) +} + +// optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 3; +inline bool AccountState::has_parental_control_info() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void AccountState::set_has_parental_control_info() { + _has_bits_[0] |= 0x00000004u; +} +inline void AccountState::clear_has_parental_control_info() { + _has_bits_[0] &= ~0x00000004u; +} +inline void AccountState::clear_parental_control_info() { + if (parental_control_info_ != NULL) parental_control_info_->::bgs::protocol::account::v1::ParentalControlInfo::Clear(); + clear_has_parental_control_info(); +} +inline const ::bgs::protocol::account::v1::ParentalControlInfo& AccountState::parental_control_info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountState.parental_control_info) + return parental_control_info_ != NULL ? *parental_control_info_ : *default_instance_->parental_control_info_; +} +inline ::bgs::protocol::account::v1::ParentalControlInfo* AccountState::mutable_parental_control_info() { + set_has_parental_control_info(); + if (parental_control_info_ == NULL) parental_control_info_ = new ::bgs::protocol::account::v1::ParentalControlInfo; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountState.parental_control_info) + return parental_control_info_; +} +inline ::bgs::protocol::account::v1::ParentalControlInfo* AccountState::release_parental_control_info() { + clear_has_parental_control_info(); + ::bgs::protocol::account::v1::ParentalControlInfo* temp = parental_control_info_; + parental_control_info_ = NULL; + return temp; +} +inline void AccountState::set_allocated_parental_control_info(::bgs::protocol::account::v1::ParentalControlInfo* parental_control_info) { + delete parental_control_info_; + parental_control_info_ = parental_control_info; + if (parental_control_info) { + set_has_parental_control_info(); + } else { + clear_has_parental_control_info(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountState.parental_control_info) +} + +// repeated .bgs.protocol.account.v1.GameLevelInfo game_level_info = 5; +inline int AccountState::game_level_info_size() const { + return game_level_info_.size(); +} +inline void AccountState::clear_game_level_info() { + game_level_info_.Clear(); +} +inline const ::bgs::protocol::account::v1::GameLevelInfo& AccountState::game_level_info(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountState.game_level_info) + return game_level_info_.Get(index); +} +inline ::bgs::protocol::account::v1::GameLevelInfo* AccountState::mutable_game_level_info(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountState.game_level_info) + return game_level_info_.Mutable(index); +} +inline ::bgs::protocol::account::v1::GameLevelInfo* AccountState::add_game_level_info() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountState.game_level_info) + return game_level_info_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameLevelInfo >& +AccountState::game_level_info() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountState.game_level_info) + return game_level_info_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameLevelInfo >* +AccountState::mutable_game_level_info() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountState.game_level_info) + return &game_level_info_; +} + +// repeated .bgs.protocol.account.v1.GameStatus game_status = 6; +inline int AccountState::game_status_size() const { + return game_status_.size(); +} +inline void AccountState::clear_game_status() { + game_status_.Clear(); +} +inline const ::bgs::protocol::account::v1::GameStatus& AccountState::game_status(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountState.game_status) + return game_status_.Get(index); +} +inline ::bgs::protocol::account::v1::GameStatus* AccountState::mutable_game_status(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountState.game_status) + return game_status_.Mutable(index); +} +inline ::bgs::protocol::account::v1::GameStatus* AccountState::add_game_status() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountState.game_status) + return game_status_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameStatus >& +AccountState::game_status() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountState.game_status) + return game_status_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameStatus >* +AccountState::mutable_game_status() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountState.game_status) + return &game_status_; +} + +// repeated .bgs.protocol.account.v1.GameAccountList game_accounts = 7; +inline int AccountState::game_accounts_size() const { + return game_accounts_.size(); +} +inline void AccountState::clear_game_accounts() { + game_accounts_.Clear(); +} +inline const ::bgs::protocol::account::v1::GameAccountList& AccountState::game_accounts(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountState.game_accounts) + return game_accounts_.Get(index); +} +inline ::bgs::protocol::account::v1::GameAccountList* AccountState::mutable_game_accounts(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountState.game_accounts) + return game_accounts_.Mutable(index); +} +inline ::bgs::protocol::account::v1::GameAccountList* AccountState::add_game_accounts() { + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountState.game_accounts) + return game_accounts_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList >& +AccountState::game_accounts() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountState.game_accounts) + return game_accounts_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList >* +AccountState::mutable_game_accounts() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountState.game_accounts) + return &game_accounts_; +} + +// ------------------------------------------------------------------- + +// AccountStateTagged + +// optional .bgs.protocol.account.v1.AccountState account_state = 1; +inline bool AccountStateTagged::has_account_state() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AccountStateTagged::set_has_account_state() { + _has_bits_[0] |= 0x00000001u; +} +inline void AccountStateTagged::clear_has_account_state() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AccountStateTagged::clear_account_state() { + if (account_state_ != NULL) account_state_->::bgs::protocol::account::v1::AccountState::Clear(); + clear_has_account_state(); +} +inline const ::bgs::protocol::account::v1::AccountState& AccountStateTagged::account_state() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountStateTagged.account_state) + return account_state_ != NULL ? *account_state_ : *default_instance_->account_state_; +} +inline ::bgs::protocol::account::v1::AccountState* AccountStateTagged::mutable_account_state() { + set_has_account_state(); + if (account_state_ == NULL) account_state_ = new ::bgs::protocol::account::v1::AccountState; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountStateTagged.account_state) + return account_state_; +} +inline ::bgs::protocol::account::v1::AccountState* AccountStateTagged::release_account_state() { + clear_has_account_state(); + ::bgs::protocol::account::v1::AccountState* temp = account_state_; + account_state_ = NULL; + return temp; +} +inline void AccountStateTagged::set_allocated_account_state(::bgs::protocol::account::v1::AccountState* account_state) { + delete account_state_; + account_state_ = account_state; + if (account_state) { + set_has_account_state(); + } else { + clear_has_account_state(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountStateTagged.account_state) +} + +// optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 2; +inline bool AccountStateTagged::has_account_tags() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void AccountStateTagged::set_has_account_tags() { + _has_bits_[0] |= 0x00000002u; +} +inline void AccountStateTagged::clear_has_account_tags() { + _has_bits_[0] &= ~0x00000002u; +} +inline void AccountStateTagged::clear_account_tags() { + if (account_tags_ != NULL) account_tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear(); + clear_has_account_tags(); +} +inline const ::bgs::protocol::account::v1::AccountFieldTags& AccountStateTagged::account_tags() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountStateTagged.account_tags) + return account_tags_ != NULL ? *account_tags_ : *default_instance_->account_tags_; +} +inline ::bgs::protocol::account::v1::AccountFieldTags* AccountStateTagged::mutable_account_tags() { + set_has_account_tags(); + if (account_tags_ == NULL) account_tags_ = new ::bgs::protocol::account::v1::AccountFieldTags; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountStateTagged.account_tags) + return account_tags_; +} +inline ::bgs::protocol::account::v1::AccountFieldTags* AccountStateTagged::release_account_tags() { + clear_has_account_tags(); + ::bgs::protocol::account::v1::AccountFieldTags* temp = account_tags_; + account_tags_ = NULL; + return temp; +} +inline void AccountStateTagged::set_allocated_account_tags(::bgs::protocol::account::v1::AccountFieldTags* account_tags) { + delete account_tags_; + account_tags_ = account_tags; + if (account_tags) { + set_has_account_tags(); + } else { + clear_has_account_tags(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountStateTagged.account_tags) +} + +// ------------------------------------------------------------------- + +// GameAccountState + +// optional .bgs.protocol.account.v1.GameLevelInfo game_level_info = 1; +inline bool GameAccountState::has_game_level_info() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GameAccountState::set_has_game_level_info() { + _has_bits_[0] |= 0x00000001u; +} +inline void GameAccountState::clear_has_game_level_info() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GameAccountState::clear_game_level_info() { + if (game_level_info_ != NULL) game_level_info_->::bgs::protocol::account::v1::GameLevelInfo::Clear(); + clear_has_game_level_info(); +} +inline const ::bgs::protocol::account::v1::GameLevelInfo& GameAccountState::game_level_info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountState.game_level_info) + return game_level_info_ != NULL ? *game_level_info_ : *default_instance_->game_level_info_; +} +inline ::bgs::protocol::account::v1::GameLevelInfo* GameAccountState::mutable_game_level_info() { + set_has_game_level_info(); + if (game_level_info_ == NULL) game_level_info_ = new ::bgs::protocol::account::v1::GameLevelInfo; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountState.game_level_info) + return game_level_info_; +} +inline ::bgs::protocol::account::v1::GameLevelInfo* GameAccountState::release_game_level_info() { + clear_has_game_level_info(); + ::bgs::protocol::account::v1::GameLevelInfo* temp = game_level_info_; + game_level_info_ = NULL; + return temp; +} +inline void GameAccountState::set_allocated_game_level_info(::bgs::protocol::account::v1::GameLevelInfo* game_level_info) { + delete game_level_info_; + game_level_info_ = game_level_info; + if (game_level_info) { + set_has_game_level_info(); + } else { + clear_has_game_level_info(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountState.game_level_info) +} + +// optional .bgs.protocol.account.v1.GameTimeInfo game_time_info = 2; +inline bool GameAccountState::has_game_time_info() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GameAccountState::set_has_game_time_info() { + _has_bits_[0] |= 0x00000002u; +} +inline void GameAccountState::clear_has_game_time_info() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GameAccountState::clear_game_time_info() { + if (game_time_info_ != NULL) game_time_info_->::bgs::protocol::account::v1::GameTimeInfo::Clear(); + clear_has_game_time_info(); +} +inline const ::bgs::protocol::account::v1::GameTimeInfo& GameAccountState::game_time_info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountState.game_time_info) + return game_time_info_ != NULL ? *game_time_info_ : *default_instance_->game_time_info_; +} +inline ::bgs::protocol::account::v1::GameTimeInfo* GameAccountState::mutable_game_time_info() { + set_has_game_time_info(); + if (game_time_info_ == NULL) game_time_info_ = new ::bgs::protocol::account::v1::GameTimeInfo; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountState.game_time_info) + return game_time_info_; +} +inline ::bgs::protocol::account::v1::GameTimeInfo* GameAccountState::release_game_time_info() { + clear_has_game_time_info(); + ::bgs::protocol::account::v1::GameTimeInfo* temp = game_time_info_; + game_time_info_ = NULL; + return temp; +} +inline void GameAccountState::set_allocated_game_time_info(::bgs::protocol::account::v1::GameTimeInfo* game_time_info) { + delete game_time_info_; + game_time_info_ = game_time_info; + if (game_time_info) { + set_has_game_time_info(); + } else { + clear_has_game_time_info(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountState.game_time_info) +} + +// optional .bgs.protocol.account.v1.GameStatus game_status = 3; +inline bool GameAccountState::has_game_status() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GameAccountState::set_has_game_status() { + _has_bits_[0] |= 0x00000004u; +} +inline void GameAccountState::clear_has_game_status() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GameAccountState::clear_game_status() { + if (game_status_ != NULL) game_status_->::bgs::protocol::account::v1::GameStatus::Clear(); + clear_has_game_status(); +} +inline const ::bgs::protocol::account::v1::GameStatus& GameAccountState::game_status() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountState.game_status) + return game_status_ != NULL ? *game_status_ : *default_instance_->game_status_; +} +inline ::bgs::protocol::account::v1::GameStatus* GameAccountState::mutable_game_status() { + set_has_game_status(); + if (game_status_ == NULL) game_status_ = new ::bgs::protocol::account::v1::GameStatus; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountState.game_status) + return game_status_; +} +inline ::bgs::protocol::account::v1::GameStatus* GameAccountState::release_game_status() { + clear_has_game_status(); + ::bgs::protocol::account::v1::GameStatus* temp = game_status_; + game_status_ = NULL; + return temp; +} +inline void GameAccountState::set_allocated_game_status(::bgs::protocol::account::v1::GameStatus* game_status) { + delete game_status_; + game_status_ = game_status; + if (game_status) { + set_has_game_status(); + } else { + clear_has_game_status(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountState.game_status) +} + +// optional .bgs.protocol.account.v1.RAFInfo raf_info = 4; +inline bool GameAccountState::has_raf_info() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void GameAccountState::set_has_raf_info() { + _has_bits_[0] |= 0x00000008u; +} +inline void GameAccountState::clear_has_raf_info() { + _has_bits_[0] &= ~0x00000008u; +} +inline void GameAccountState::clear_raf_info() { + if (raf_info_ != NULL) raf_info_->::bgs::protocol::account::v1::RAFInfo::Clear(); + clear_has_raf_info(); +} +inline const ::bgs::protocol::account::v1::RAFInfo& GameAccountState::raf_info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountState.raf_info) + return raf_info_ != NULL ? *raf_info_ : *default_instance_->raf_info_; +} +inline ::bgs::protocol::account::v1::RAFInfo* GameAccountState::mutable_raf_info() { + set_has_raf_info(); + if (raf_info_ == NULL) raf_info_ = new ::bgs::protocol::account::v1::RAFInfo; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountState.raf_info) + return raf_info_; +} +inline ::bgs::protocol::account::v1::RAFInfo* GameAccountState::release_raf_info() { + clear_has_raf_info(); + ::bgs::protocol::account::v1::RAFInfo* temp = raf_info_; + raf_info_ = NULL; + return temp; +} +inline void GameAccountState::set_allocated_raf_info(::bgs::protocol::account::v1::RAFInfo* raf_info) { + delete raf_info_; + raf_info_ = raf_info; + if (raf_info) { + set_has_raf_info(); + } else { + clear_has_raf_info(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountState.raf_info) +} + +// ------------------------------------------------------------------- + +// GameAccountStateTagged + +// optional .bgs.protocol.account.v1.GameAccountState game_account_state = 1; +inline bool GameAccountStateTagged::has_game_account_state() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GameAccountStateTagged::set_has_game_account_state() { + _has_bits_[0] |= 0x00000001u; +} +inline void GameAccountStateTagged::clear_has_game_account_state() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GameAccountStateTagged::clear_game_account_state() { + if (game_account_state_ != NULL) game_account_state_->::bgs::protocol::account::v1::GameAccountState::Clear(); + clear_has_game_account_state(); +} +inline const ::bgs::protocol::account::v1::GameAccountState& GameAccountStateTagged::game_account_state() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountStateTagged.game_account_state) + return game_account_state_ != NULL ? *game_account_state_ : *default_instance_->game_account_state_; +} +inline ::bgs::protocol::account::v1::GameAccountState* GameAccountStateTagged::mutable_game_account_state() { + set_has_game_account_state(); + if (game_account_state_ == NULL) game_account_state_ = new ::bgs::protocol::account::v1::GameAccountState; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountStateTagged.game_account_state) + return game_account_state_; +} +inline ::bgs::protocol::account::v1::GameAccountState* GameAccountStateTagged::release_game_account_state() { + clear_has_game_account_state(); + ::bgs::protocol::account::v1::GameAccountState* temp = game_account_state_; + game_account_state_ = NULL; + return temp; +} +inline void GameAccountStateTagged::set_allocated_game_account_state(::bgs::protocol::account::v1::GameAccountState* game_account_state) { + delete game_account_state_; + game_account_state_ = game_account_state; + if (game_account_state) { + set_has_game_account_state(); + } else { + clear_has_game_account_state(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountStateTagged.game_account_state) +} + +// optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 2; +inline bool GameAccountStateTagged::has_game_account_tags() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GameAccountStateTagged::set_has_game_account_tags() { + _has_bits_[0] |= 0x00000002u; +} +inline void GameAccountStateTagged::clear_has_game_account_tags() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GameAccountStateTagged::clear_game_account_tags() { + if (game_account_tags_ != NULL) game_account_tags_->::bgs::protocol::account::v1::GameAccountFieldTags::Clear(); + clear_has_game_account_tags(); +} +inline const ::bgs::protocol::account::v1::GameAccountFieldTags& GameAccountStateTagged::game_account_tags() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountStateTagged.game_account_tags) + return game_account_tags_ != NULL ? *game_account_tags_ : *default_instance_->game_account_tags_; +} +inline ::bgs::protocol::account::v1::GameAccountFieldTags* GameAccountStateTagged::mutable_game_account_tags() { + set_has_game_account_tags(); + if (game_account_tags_ == NULL) game_account_tags_ = new ::bgs::protocol::account::v1::GameAccountFieldTags; + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountStateTagged.game_account_tags) + return game_account_tags_; +} +inline ::bgs::protocol::account::v1::GameAccountFieldTags* GameAccountStateTagged::release_game_account_tags() { + clear_has_game_account_tags(); + ::bgs::protocol::account::v1::GameAccountFieldTags* temp = game_account_tags_; + game_account_tags_ = NULL; + return temp; +} +inline void GameAccountStateTagged::set_allocated_game_account_tags(::bgs::protocol::account::v1::GameAccountFieldTags* game_account_tags) { + delete game_account_tags_; + game_account_tags_ = game_account_tags; + if (game_account_tags) { + set_has_game_account_tags(); + } else { + clear_has_game_account_tags(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountStateTagged.game_account_tags) +} + +// ------------------------------------------------------------------- + +// AuthorizedData + +// optional string data = 1; +inline bool AuthorizedData::has_data() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AuthorizedData::set_has_data() { + _has_bits_[0] |= 0x00000001u; +} +inline void AuthorizedData::clear_has_data() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AuthorizedData::clear_data() { + if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_->clear(); + } + clear_has_data(); +} +inline const ::std::string& AuthorizedData::data() const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AuthorizedData.data) + return *data_; +} +inline void AuthorizedData::set_data(const ::std::string& value) { + set_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_ = new ::std::string; + } + data_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AuthorizedData.data) +} +inline void AuthorizedData::set_data(const char* value) { + set_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_ = new ::std::string; + } + data_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AuthorizedData.data) +} +inline void AuthorizedData::set_data(const char* value, size_t size) { + set_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_ = new ::std::string; + } + data_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AuthorizedData.data) +} +inline ::std::string* AuthorizedData::mutable_data() { + set_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AuthorizedData.data) + return data_; +} +inline ::std::string* AuthorizedData::release_data() { + clear_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = data_; + data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void AuthorizedData::set_allocated_data(::std::string* data) { + if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete data_; + } + if (data) { + set_has_data(); + data_ = data; + } else { + clear_has_data(); + data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AuthorizedData.data) +} + +// repeated uint32 license = 2; +inline int AuthorizedData::license_size() const { + return license_.size(); +} +inline void AuthorizedData::clear_license() { + license_.Clear(); +} +inline ::google::protobuf::uint32 AuthorizedData::license(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AuthorizedData.license) + return license_.Get(index); +} +inline void AuthorizedData::set_license(int index, ::google::protobuf::uint32 value) { + license_.Set(index, value); + // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AuthorizedData.license) +} +inline void AuthorizedData::add_license(::google::protobuf::uint32 value) { + license_.Add(value); + // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AuthorizedData.license) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +AuthorizedData::license() const { + // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AuthorizedData.license) + return license_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +AuthorizedData::mutable_license() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AuthorizedData.license) + return &license_; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace account +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + +template <> struct is_proto_enum< ::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy>() { + return ::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy_descriptor(); +} +template <> struct is_proto_enum< ::bgs::protocol::account::v1::IdentityVerificationStatus> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::account::v1::IdentityVerificationStatus>() { + return ::bgs::protocol::account::v1::IdentityVerificationStatus_descriptor(); +} + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_account_5ftypes_2eproto__INCLUDED diff --git a/src/server/proto/Client/attribute_types.pb.cc b/src/server/proto/Client/attribute_types.pb.cc new file mode 100644 index 00000000000..105a72cf1bb --- /dev/null +++ b/src/server/proto/Client/attribute_types.pb.cc @@ -0,0 +1,1385 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: attribute_types.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "attribute_types.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { + +namespace { + +const ::google::protobuf::Descriptor* Variant_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Variant_reflection_ = NULL; +const ::google::protobuf::Descriptor* Attribute_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Attribute_reflection_ = NULL; +const ::google::protobuf::Descriptor* AttributeFilter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AttributeFilter_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* AttributeFilter_Operation_descriptor_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_attribute_5ftypes_2eproto() { + protobuf_AddDesc_attribute_5ftypes_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "attribute_types.proto"); + GOOGLE_CHECK(file != NULL); + Variant_descriptor_ = file->message_type(0); + static const int Variant_offsets_[9] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, bool_value_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, int_value_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, float_value_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, string_value_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, blob_value_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, message_value_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, fourcc_value_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, uint_value_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, entity_id_value_), + }; + Variant_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Variant_descriptor_, + Variant::default_instance_, + Variant_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Variant)); + Attribute_descriptor_ = file->message_type(1); + static const int Attribute_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Attribute, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Attribute, value_), + }; + Attribute_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Attribute_descriptor_, + Attribute::default_instance_, + Attribute_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Attribute, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Attribute, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Attribute)); + AttributeFilter_descriptor_ = file->message_type(2); + static const int AttributeFilter_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AttributeFilter, op_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AttributeFilter, attribute_), + }; + AttributeFilter_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AttributeFilter_descriptor_, + AttributeFilter::default_instance_, + AttributeFilter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AttributeFilter, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AttributeFilter, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AttributeFilter)); + AttributeFilter_Operation_descriptor_ = AttributeFilter_descriptor_->enum_type(0); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_attribute_5ftypes_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Variant_descriptor_, &Variant::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Attribute_descriptor_, &Attribute::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AttributeFilter_descriptor_, &AttributeFilter::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_attribute_5ftypes_2eproto() { + delete Variant::default_instance_; + delete Variant_reflection_; + delete Attribute::default_instance_; + delete Attribute_reflection_; + delete AttributeFilter::default_instance_; + delete AttributeFilter_reflection_; +} + +void protobuf_AddDesc_attribute_5ftypes_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\025attribute_types.proto\022\014bgs.protocol\032\022e" + "ntity_types.proto\"\341\001\n\007Variant\022\022\n\nbool_va" + "lue\030\002 \001(\010\022\021\n\tint_value\030\003 \001(\003\022\023\n\013float_va" + "lue\030\004 \001(\001\022\024\n\014string_value\030\005 \001(\t\022\022\n\nblob_" + "value\030\006 \001(\014\022\025\n\rmessage_value\030\007 \001(\014\022\024\n\014fo" + "urcc_value\030\010 \001(\t\022\022\n\nuint_value\030\t \001(\004\022/\n\017" + "entity_id_value\030\n \001(\0132\026.bgs.protocol.Ent" + "ityId\"\?\n\tAttribute\022\014\n\004name\030\001 \002(\t\022$\n\005valu" + "e\030\002 \002(\0132\025.bgs.protocol.Variant\"\312\001\n\017Attri" + "buteFilter\0223\n\002op\030\001 \002(\0162\'.bgs.protocol.At" + "tributeFilter.Operation\022*\n\tattribute\030\002 \003" + "(\0132\027.bgs.protocol.Attribute\"V\n\tOperation" + "\022\016\n\nMATCH_NONE\020\000\022\r\n\tMATCH_ANY\020\001\022\r\n\tMATCH" + "_ALL\020\002\022\033\n\027MATCH_ALL_MOST_SPECIFIC\020\003B!\n\rb" + "net.protocolB\016AttributeProtoH\001", 590); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "attribute_types.proto", &protobuf_RegisterTypes); + Variant::default_instance_ = new Variant(); + Attribute::default_instance_ = new Attribute(); + AttributeFilter::default_instance_ = new AttributeFilter(); + Variant::default_instance_->InitAsDefaultInstance(); + Attribute::default_instance_->InitAsDefaultInstance(); + AttributeFilter::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_attribute_5ftypes_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_attribute_5ftypes_2eproto { + StaticDescriptorInitializer_attribute_5ftypes_2eproto() { + protobuf_AddDesc_attribute_5ftypes_2eproto(); + } +} static_descriptor_initializer_attribute_5ftypes_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int Variant::kBoolValueFieldNumber; +const int Variant::kIntValueFieldNumber; +const int Variant::kFloatValueFieldNumber; +const int Variant::kStringValueFieldNumber; +const int Variant::kBlobValueFieldNumber; +const int Variant::kMessageValueFieldNumber; +const int Variant::kFourccValueFieldNumber; +const int Variant::kUintValueFieldNumber; +const int Variant::kEntityIdValueFieldNumber; +#endif // !_MSC_VER + +Variant::Variant() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.Variant) +} + +void Variant::InitAsDefaultInstance() { + entity_id_value_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +Variant::Variant(const Variant& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.Variant) +} + +void Variant::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + bool_value_ = false; + int_value_ = GOOGLE_LONGLONG(0); + float_value_ = 0; + string_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + blob_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + message_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + fourcc_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + uint_value_ = GOOGLE_ULONGLONG(0); + entity_id_value_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Variant::~Variant() { + // @@protoc_insertion_point(destructor:bgs.protocol.Variant) + SharedDtor(); +} + +void Variant::SharedDtor() { + if (string_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete string_value_; + } + if (blob_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete blob_value_; + } + if (message_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete message_value_; + } + if (fourcc_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete fourcc_value_; + } + if (this != default_instance_) { + delete entity_id_value_; + } +} + +void Variant::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Variant::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Variant_descriptor_; +} + +const Variant& Variant::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_attribute_5ftypes_2eproto(); + return *default_instance_; +} + +Variant* Variant::default_instance_ = NULL; + +Variant* Variant::New() const { + return new Variant; +} + +void Variant::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(int_value_, float_value_); + bool_value_ = false; + if (has_string_value()) { + if (string_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + string_value_->clear(); + } + } + if (has_blob_value()) { + if (blob_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + blob_value_->clear(); + } + } + if (has_message_value()) { + if (message_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + message_value_->clear(); + } + } + if (has_fourcc_value()) { + if (fourcc_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + fourcc_value_->clear(); + } + } + uint_value_ = GOOGLE_ULONGLONG(0); + } + if (has_entity_id_value()) { + if (entity_id_value_ != NULL) entity_id_value_->::bgs::protocol::EntityId::Clear(); + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Variant::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.Variant) + 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 bool_value = 2; + case 2: { + if (tag == 16) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &bool_value_))); + set_has_bool_value(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_int_value; + break; + } + + // optional int64 int_value = 3; + case 3: { + if (tag == 24) { + parse_int_value: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &int_value_))); + set_has_int_value(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(33)) goto parse_float_value; + break; + } + + // optional double float_value = 4; + case 4: { + if (tag == 33) { + parse_float_value: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + input, &float_value_))); + set_has_float_value(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_string_value; + break; + } + + // optional string string_value = 5; + case 5: { + if (tag == 42) { + parse_string_value: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_string_value())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->string_value().data(), this->string_value().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "string_value"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_blob_value; + break; + } + + // optional bytes blob_value = 6; + case 6: { + if (tag == 50) { + parse_blob_value: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_blob_value())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(58)) goto parse_message_value; + break; + } + + // optional bytes message_value = 7; + case 7: { + if (tag == 58) { + parse_message_value: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_message_value())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(66)) goto parse_fourcc_value; + break; + } + + // optional string fourcc_value = 8; + case 8: { + if (tag == 66) { + parse_fourcc_value: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_fourcc_value())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->fourcc_value().data(), this->fourcc_value().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "fourcc_value"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(72)) goto parse_uint_value; + break; + } + + // optional uint64 uint_value = 9; + case 9: { + if (tag == 72) { + parse_uint_value: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &uint_value_))); + set_has_uint_value(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(82)) goto parse_entity_id_value; + break; + } + + // optional .bgs.protocol.EntityId entity_id_value = 10; + case 10: { + if (tag == 82) { + parse_entity_id_value: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_entity_id_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:bgs.protocol.Variant) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.Variant) + return false; +#undef DO_ +} + +void Variant::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.Variant) + // optional bool bool_value = 2; + if (has_bool_value()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->bool_value(), output); + } + + // optional int64 int_value = 3; + if (has_int_value()) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(3, this->int_value(), output); + } + + // optional double float_value = 4; + if (has_float_value()) { + ::google::protobuf::internal::WireFormatLite::WriteDouble(4, this->float_value(), output); + } + + // optional string string_value = 5; + if (has_string_value()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->string_value().data(), this->string_value().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "string_value"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 5, this->string_value(), output); + } + + // optional bytes blob_value = 6; + if (has_blob_value()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 6, this->blob_value(), output); + } + + // optional bytes message_value = 7; + if (has_message_value()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 7, this->message_value(), output); + } + + // optional string fourcc_value = 8; + if (has_fourcc_value()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->fourcc_value().data(), this->fourcc_value().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "fourcc_value"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 8, this->fourcc_value(), output); + } + + // optional uint64 uint_value = 9; + if (has_uint_value()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(9, this->uint_value(), output); + } + + // optional .bgs.protocol.EntityId entity_id_value = 10; + if (has_entity_id_value()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 10, this->entity_id_value(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.Variant) +} + +::google::protobuf::uint8* Variant::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.Variant) + // optional bool bool_value = 2; + if (has_bool_value()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->bool_value(), target); + } + + // optional int64 int_value = 3; + if (has_int_value()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(3, this->int_value(), target); + } + + // optional double float_value = 4; + if (has_float_value()) { + target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(4, this->float_value(), target); + } + + // optional string string_value = 5; + if (has_string_value()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->string_value().data(), this->string_value().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "string_value"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 5, this->string_value(), target); + } + + // optional bytes blob_value = 6; + if (has_blob_value()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 6, this->blob_value(), target); + } + + // optional bytes message_value = 7; + if (has_message_value()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 7, this->message_value(), target); + } + + // optional string fourcc_value = 8; + if (has_fourcc_value()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->fourcc_value().data(), this->fourcc_value().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "fourcc_value"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 8, this->fourcc_value(), target); + } + + // optional uint64 uint_value = 9; + if (has_uint_value()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(9, this->uint_value(), target); + } + + // optional .bgs.protocol.EntityId entity_id_value = 10; + if (has_entity_id_value()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 10, this->entity_id_value(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.Variant) + return target; +} + +int Variant::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional bool bool_value = 2; + if (has_bool_value()) { + total_size += 1 + 1; + } + + // optional int64 int_value = 3; + if (has_int_value()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->int_value()); + } + + // optional double float_value = 4; + if (has_float_value()) { + total_size += 1 + 8; + } + + // optional string string_value = 5; + if (has_string_value()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->string_value()); + } + + // optional bytes blob_value = 6; + if (has_blob_value()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->blob_value()); + } + + // optional bytes message_value = 7; + if (has_message_value()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->message_value()); + } + + // optional string fourcc_value = 8; + if (has_fourcc_value()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->fourcc_value()); + } + + // optional uint64 uint_value = 9; + if (has_uint_value()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->uint_value()); + } + + } + if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + // optional .bgs.protocol.EntityId entity_id_value = 10; + if (has_entity_id_value()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->entity_id_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 Variant::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Variant* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Variant::MergeFrom(const Variant& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_bool_value()) { + set_bool_value(from.bool_value()); + } + if (from.has_int_value()) { + set_int_value(from.int_value()); + } + if (from.has_float_value()) { + set_float_value(from.float_value()); + } + if (from.has_string_value()) { + set_string_value(from.string_value()); + } + if (from.has_blob_value()) { + set_blob_value(from.blob_value()); + } + if (from.has_message_value()) { + set_message_value(from.message_value()); + } + if (from.has_fourcc_value()) { + set_fourcc_value(from.fourcc_value()); + } + if (from.has_uint_value()) { + set_uint_value(from.uint_value()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from.has_entity_id_value()) { + mutable_entity_id_value()->::bgs::protocol::EntityId::MergeFrom(from.entity_id_value()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Variant::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Variant::CopyFrom(const Variant& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Variant::IsInitialized() const { + + if (has_entity_id_value()) { + if (!this->entity_id_value().IsInitialized()) return false; + } + return true; +} + +void Variant::Swap(Variant* other) { + if (other != this) { + std::swap(bool_value_, other->bool_value_); + std::swap(int_value_, other->int_value_); + std::swap(float_value_, other->float_value_); + std::swap(string_value_, other->string_value_); + std::swap(blob_value_, other->blob_value_); + std::swap(message_value_, other->message_value_); + std::swap(fourcc_value_, other->fourcc_value_); + std::swap(uint_value_, other->uint_value_); + std::swap(entity_id_value_, other->entity_id_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 Variant::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Variant_descriptor_; + metadata.reflection = Variant_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int Attribute::kNameFieldNumber; +const int Attribute::kValueFieldNumber; +#endif // !_MSC_VER + +Attribute::Attribute() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.Attribute) +} + +void Attribute::InitAsDefaultInstance() { + value_ = const_cast< ::bgs::protocol::Variant*>(&::bgs::protocol::Variant::default_instance()); +} + +Attribute::Attribute(const Attribute& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.Attribute) +} + +void Attribute::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + value_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Attribute::~Attribute() { + // @@protoc_insertion_point(destructor:bgs.protocol.Attribute) + SharedDtor(); +} + +void Attribute::SharedDtor() { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete name_; + } + if (this != default_instance_) { + delete value_; + } +} + +void Attribute::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Attribute::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Attribute_descriptor_; +} + +const Attribute& Attribute::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_attribute_5ftypes_2eproto(); + return *default_instance_; +} + +Attribute* Attribute::default_instance_ = NULL; + +Attribute* Attribute::New() const { + return new Attribute; +} + +void Attribute::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_name()) { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_->clear(); + } + } + if (has_value()) { + if (value_ != NULL) value_->::bgs::protocol::Variant::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Attribute::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.Attribute) + 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)) { + // required 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(18)) goto parse_value; + break; + } + + // required .bgs.protocol.Variant value = 2; + case 2: { + if (tag == 18) { + parse_value: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_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:bgs.protocol.Attribute) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.Attribute) + return false; +#undef DO_ +} + +void Attribute::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.Attribute) + // required 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); + } + + // required .bgs.protocol.Variant value = 2; + if (has_value()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->value(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.Attribute) +} + +::google::protobuf::uint8* Attribute::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.Attribute) + // required 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); + } + + // required .bgs.protocol.Variant value = 2; + if (has_value()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->value(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.Attribute) + return target; +} + +int Attribute::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string name = 1; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // required .bgs.protocol.Variant value = 2; + if (has_value()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + 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 Attribute::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Attribute* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Attribute::MergeFrom(const Attribute& 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_value()) { + mutable_value()->::bgs::protocol::Variant::MergeFrom(from.value()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Attribute::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Attribute::CopyFrom(const Attribute& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Attribute::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + if (has_value()) { + if (!this->value().IsInitialized()) return false; + } + return true; +} + +void Attribute::Swap(Attribute* other) { + if (other != this) { + 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 Attribute::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Attribute_descriptor_; + metadata.reflection = Attribute_reflection_; + return metadata; +} + + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* AttributeFilter_Operation_descriptor() { + protobuf_AssignDescriptorsOnce(); + return AttributeFilter_Operation_descriptor_; +} +bool AttributeFilter_Operation_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + +#ifndef _MSC_VER +const AttributeFilter_Operation AttributeFilter::MATCH_NONE; +const AttributeFilter_Operation AttributeFilter::MATCH_ANY; +const AttributeFilter_Operation AttributeFilter::MATCH_ALL; +const AttributeFilter_Operation AttributeFilter::MATCH_ALL_MOST_SPECIFIC; +const AttributeFilter_Operation AttributeFilter::Operation_MIN; +const AttributeFilter_Operation AttributeFilter::Operation_MAX; +const int AttributeFilter::Operation_ARRAYSIZE; +#endif // _MSC_VER +#ifndef _MSC_VER +const int AttributeFilter::kOpFieldNumber; +const int AttributeFilter::kAttributeFieldNumber; +#endif // !_MSC_VER + +AttributeFilter::AttributeFilter() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.AttributeFilter) +} + +void AttributeFilter::InitAsDefaultInstance() { +} + +AttributeFilter::AttributeFilter(const AttributeFilter& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.AttributeFilter) +} + +void AttributeFilter::SharedCtor() { + _cached_size_ = 0; + op_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AttributeFilter::~AttributeFilter() { + // @@protoc_insertion_point(destructor:bgs.protocol.AttributeFilter) + SharedDtor(); +} + +void AttributeFilter::SharedDtor() { + if (this != default_instance_) { + } +} + +void AttributeFilter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AttributeFilter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AttributeFilter_descriptor_; +} + +const AttributeFilter& AttributeFilter::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_attribute_5ftypes_2eproto(); + return *default_instance_; +} + +AttributeFilter* AttributeFilter::default_instance_ = NULL; + +AttributeFilter* AttributeFilter::New() const { + return new AttributeFilter; +} + +void AttributeFilter::Clear() { + op_ = 0; + attribute_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AttributeFilter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.AttributeFilter) + 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)) { + // required .bgs.protocol.AttributeFilter.Operation op = 1; + case 1: { + if (tag == 8) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::bgs::protocol::AttributeFilter_Operation_IsValid(value)) { + set_op(static_cast< ::bgs::protocol::AttributeFilter_Operation >(value)); + } else { + mutable_unknown_fields()->AddVarint(1, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_attribute; + break; + } + + // repeated .bgs.protocol.Attribute attribute = 2; + case 2: { + if (tag == 18) { + parse_attribute: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_attribute())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_attribute; + 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:bgs.protocol.AttributeFilter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.AttributeFilter) + return false; +#undef DO_ +} + +void AttributeFilter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.AttributeFilter) + // required .bgs.protocol.AttributeFilter.Operation op = 1; + if (has_op()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->op(), output); + } + + // repeated .bgs.protocol.Attribute attribute = 2; + for (int i = 0; i < this->attribute_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->attribute(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.AttributeFilter) +} + +::google::protobuf::uint8* AttributeFilter::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.AttributeFilter) + // required .bgs.protocol.AttributeFilter.Operation op = 1; + if (has_op()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 1, this->op(), target); + } + + // repeated .bgs.protocol.Attribute attribute = 2; + for (int i = 0; i < this->attribute_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->attribute(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.AttributeFilter) + return target; +} + +int AttributeFilter::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.AttributeFilter.Operation op = 1; + if (has_op()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->op()); + } + + } + // repeated .bgs.protocol.Attribute attribute = 2; + total_size += 1 * this->attribute_size(); + for (int i = 0; i < this->attribute_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->attribute(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 AttributeFilter::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AttributeFilter* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AttributeFilter::MergeFrom(const AttributeFilter& from) { + GOOGLE_CHECK_NE(&from, this); + attribute_.MergeFrom(from.attribute_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_op()) { + set_op(from.op()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AttributeFilter::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AttributeFilter::CopyFrom(const AttributeFilter& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AttributeFilter::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false; + return true; +} + +void AttributeFilter::Swap(AttributeFilter* other) { + if (other != this) { + std::swap(op_, other->op_); + attribute_.Swap(&other->attribute_); + 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 AttributeFilter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AttributeFilter_descriptor_; + metadata.reflection = AttributeFilter_reflection_; + return metadata; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/attribute_types.pb.h b/src/server/proto/Client/attribute_types.pb.h new file mode 100644 index 00000000000..78c3e1caf0a --- /dev/null +++ b/src/server/proto/Client/attribute_types.pb.h @@ -0,0 +1,1113 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: attribute_types.proto + +#ifndef PROTOBUF_attribute_5ftypes_2eproto__INCLUDED +#define PROTOBUF_attribute_5ftypes_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include +#include "entity_types.pb.h" +#include "Define.h" // for TRINITY_SHARED_API +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_attribute_5ftypes_2eproto(); +void protobuf_AssignDesc_attribute_5ftypes_2eproto(); +void protobuf_ShutdownFile_attribute_5ftypes_2eproto(); + +class Variant; +class Attribute; +class AttributeFilter; + +enum AttributeFilter_Operation { + AttributeFilter_Operation_MATCH_NONE = 0, + AttributeFilter_Operation_MATCH_ANY = 1, + AttributeFilter_Operation_MATCH_ALL = 2, + AttributeFilter_Operation_MATCH_ALL_MOST_SPECIFIC = 3 +}; +TC_SHARED_API bool AttributeFilter_Operation_IsValid(int value); +const AttributeFilter_Operation AttributeFilter_Operation_Operation_MIN = AttributeFilter_Operation_MATCH_NONE; +const AttributeFilter_Operation AttributeFilter_Operation_Operation_MAX = AttributeFilter_Operation_MATCH_ALL_MOST_SPECIFIC; +const int AttributeFilter_Operation_Operation_ARRAYSIZE = AttributeFilter_Operation_Operation_MAX + 1; + +TC_SHARED_API const ::google::protobuf::EnumDescriptor* AttributeFilter_Operation_descriptor(); +inline const ::std::string& AttributeFilter_Operation_Name(AttributeFilter_Operation value) { + return ::google::protobuf::internal::NameOfEnum( + AttributeFilter_Operation_descriptor(), value); +} +inline bool AttributeFilter_Operation_Parse( + const ::std::string& name, AttributeFilter_Operation* value) { + return ::google::protobuf::internal::ParseNamedEnum( + AttributeFilter_Operation_descriptor(), name, value); +} +// =================================================================== + +class TC_SHARED_API Variant : public ::google::protobuf::Message { + public: + Variant(); + virtual ~Variant(); + + Variant(const Variant& from); + + inline Variant& operator=(const Variant& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Variant& default_instance(); + + void Swap(Variant* other); + + // implements Message ---------------------------------------------- + + Variant* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Variant& from); + void MergeFrom(const Variant& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional bool bool_value = 2; + inline bool has_bool_value() const; + inline void clear_bool_value(); + static const int kBoolValueFieldNumber = 2; + inline bool bool_value() const; + inline void set_bool_value(bool value); + + // optional int64 int_value = 3; + inline bool has_int_value() const; + inline void clear_int_value(); + static const int kIntValueFieldNumber = 3; + inline ::google::protobuf::int64 int_value() const; + inline void set_int_value(::google::protobuf::int64 value); + + // optional double float_value = 4; + inline bool has_float_value() const; + inline void clear_float_value(); + static const int kFloatValueFieldNumber = 4; + inline double float_value() const; + inline void set_float_value(double value); + + // optional string string_value = 5; + inline bool has_string_value() const; + inline void clear_string_value(); + static const int kStringValueFieldNumber = 5; + inline const ::std::string& string_value() const; + inline void set_string_value(const ::std::string& value); + inline void set_string_value(const char* value); + inline void set_string_value(const char* value, size_t size); + inline ::std::string* mutable_string_value(); + inline ::std::string* release_string_value(); + inline void set_allocated_string_value(::std::string* string_value); + + // optional bytes blob_value = 6; + inline bool has_blob_value() const; + inline void clear_blob_value(); + static const int kBlobValueFieldNumber = 6; + inline const ::std::string& blob_value() const; + inline void set_blob_value(const ::std::string& value); + inline void set_blob_value(const char* value); + inline void set_blob_value(const void* value, size_t size); + inline ::std::string* mutable_blob_value(); + inline ::std::string* release_blob_value(); + inline void set_allocated_blob_value(::std::string* blob_value); + + // optional bytes message_value = 7; + inline bool has_message_value() const; + inline void clear_message_value(); + static const int kMessageValueFieldNumber = 7; + inline const ::std::string& message_value() const; + inline void set_message_value(const ::std::string& value); + inline void set_message_value(const char* value); + inline void set_message_value(const void* value, size_t size); + inline ::std::string* mutable_message_value(); + inline ::std::string* release_message_value(); + inline void set_allocated_message_value(::std::string* message_value); + + // optional string fourcc_value = 8; + inline bool has_fourcc_value() const; + inline void clear_fourcc_value(); + static const int kFourccValueFieldNumber = 8; + inline const ::std::string& fourcc_value() const; + inline void set_fourcc_value(const ::std::string& value); + inline void set_fourcc_value(const char* value); + inline void set_fourcc_value(const char* value, size_t size); + inline ::std::string* mutable_fourcc_value(); + inline ::std::string* release_fourcc_value(); + inline void set_allocated_fourcc_value(::std::string* fourcc_value); + + // optional uint64 uint_value = 9; + inline bool has_uint_value() const; + inline void clear_uint_value(); + static const int kUintValueFieldNumber = 9; + inline ::google::protobuf::uint64 uint_value() const; + inline void set_uint_value(::google::protobuf::uint64 value); + + // optional .bgs.protocol.EntityId entity_id_value = 10; + inline bool has_entity_id_value() const; + inline void clear_entity_id_value(); + static const int kEntityIdValueFieldNumber = 10; + inline const ::bgs::protocol::EntityId& entity_id_value() const; + inline ::bgs::protocol::EntityId* mutable_entity_id_value(); + inline ::bgs::protocol::EntityId* release_entity_id_value(); + inline void set_allocated_entity_id_value(::bgs::protocol::EntityId* entity_id_value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.Variant) + private: + inline void set_has_bool_value(); + inline void clear_has_bool_value(); + inline void set_has_int_value(); + inline void clear_has_int_value(); + inline void set_has_float_value(); + inline void clear_has_float_value(); + inline void set_has_string_value(); + inline void clear_has_string_value(); + inline void set_has_blob_value(); + inline void clear_has_blob_value(); + inline void set_has_message_value(); + inline void clear_has_message_value(); + inline void set_has_fourcc_value(); + inline void clear_has_fourcc_value(); + inline void set_has_uint_value(); + inline void clear_has_uint_value(); + inline void set_has_entity_id_value(); + inline void clear_has_entity_id_value(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::int64 int_value_; + double float_value_; + ::std::string* string_value_; + ::std::string* blob_value_; + ::std::string* message_value_; + ::std::string* fourcc_value_; + ::google::protobuf::uint64 uint_value_; + ::bgs::protocol::EntityId* entity_id_value_; + bool bool_value_; + friend void TC_SHARED_API protobuf_AddDesc_attribute_5ftypes_2eproto(); + friend void protobuf_AssignDesc_attribute_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_attribute_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static Variant* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API Attribute : public ::google::protobuf::Message { + public: + Attribute(); + virtual ~Attribute(); + + Attribute(const Attribute& from); + + inline Attribute& operator=(const Attribute& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Attribute& default_instance(); + + void Swap(Attribute* other); + + // implements Message ---------------------------------------------- + + Attribute* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Attribute& from); + void MergeFrom(const Attribute& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string name = 1; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 1; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + inline ::std::string* release_name(); + inline void set_allocated_name(::std::string* name); + + // required .bgs.protocol.Variant value = 2; + inline bool has_value() const; + inline void clear_value(); + static const int kValueFieldNumber = 2; + inline const ::bgs::protocol::Variant& value() const; + inline ::bgs::protocol::Variant* mutable_value(); + inline ::bgs::protocol::Variant* release_value(); + inline void set_allocated_value(::bgs::protocol::Variant* value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.Attribute) + private: + inline void set_has_name(); + inline void clear_has_name(); + inline void set_has_value(); + inline void clear_has_value(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* name_; + ::bgs::protocol::Variant* value_; + friend void TC_SHARED_API protobuf_AddDesc_attribute_5ftypes_2eproto(); + friend void protobuf_AssignDesc_attribute_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_attribute_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static Attribute* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API AttributeFilter : public ::google::protobuf::Message { + public: + AttributeFilter(); + virtual ~AttributeFilter(); + + AttributeFilter(const AttributeFilter& from); + + inline AttributeFilter& operator=(const AttributeFilter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AttributeFilter& default_instance(); + + void Swap(AttributeFilter* other); + + // implements Message ---------------------------------------------- + + AttributeFilter* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AttributeFilter& from); + void MergeFrom(const AttributeFilter& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef AttributeFilter_Operation Operation; + static const Operation MATCH_NONE = AttributeFilter_Operation_MATCH_NONE; + static const Operation MATCH_ANY = AttributeFilter_Operation_MATCH_ANY; + static const Operation MATCH_ALL = AttributeFilter_Operation_MATCH_ALL; + static const Operation MATCH_ALL_MOST_SPECIFIC = AttributeFilter_Operation_MATCH_ALL_MOST_SPECIFIC; + static inline bool Operation_IsValid(int value) { + return AttributeFilter_Operation_IsValid(value); + } + static const Operation Operation_MIN = + AttributeFilter_Operation_Operation_MIN; + static const Operation Operation_MAX = + AttributeFilter_Operation_Operation_MAX; + static const int Operation_ARRAYSIZE = + AttributeFilter_Operation_Operation_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + Operation_descriptor() { + return AttributeFilter_Operation_descriptor(); + } + static inline const ::std::string& Operation_Name(Operation value) { + return AttributeFilter_Operation_Name(value); + } + static inline bool Operation_Parse(const ::std::string& name, + Operation* value) { + return AttributeFilter_Operation_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.AttributeFilter.Operation op = 1; + inline bool has_op() const; + inline void clear_op(); + static const int kOpFieldNumber = 1; + inline ::bgs::protocol::AttributeFilter_Operation op() const; + inline void set_op(::bgs::protocol::AttributeFilter_Operation value); + + // repeated .bgs.protocol.Attribute attribute = 2; + inline int attribute_size() const; + inline void clear_attribute(); + static const int kAttributeFieldNumber = 2; + inline const ::bgs::protocol::Attribute& attribute(int index) const; + inline ::bgs::protocol::Attribute* mutable_attribute(int index); + inline ::bgs::protocol::Attribute* add_attribute(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& + attribute() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* + mutable_attribute(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.AttributeFilter) + private: + inline void set_has_op(); + inline void clear_has_op(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_; + int op_; + friend void TC_SHARED_API protobuf_AddDesc_attribute_5ftypes_2eproto(); + friend void protobuf_AssignDesc_attribute_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_attribute_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static AttributeFilter* default_instance_; +}; +// =================================================================== + + +// =================================================================== + + +// =================================================================== + +// Variant + +// optional bool bool_value = 2; +inline bool Variant::has_bool_value() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Variant::set_has_bool_value() { + _has_bits_[0] |= 0x00000001u; +} +inline void Variant::clear_has_bool_value() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Variant::clear_bool_value() { + bool_value_ = false; + clear_has_bool_value(); +} +inline bool Variant::bool_value() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Variant.bool_value) + return bool_value_; +} +inline void Variant::set_bool_value(bool value) { + set_has_bool_value(); + bool_value_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.Variant.bool_value) +} + +// optional int64 int_value = 3; +inline bool Variant::has_int_value() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Variant::set_has_int_value() { + _has_bits_[0] |= 0x00000002u; +} +inline void Variant::clear_has_int_value() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Variant::clear_int_value() { + int_value_ = GOOGLE_LONGLONG(0); + clear_has_int_value(); +} +inline ::google::protobuf::int64 Variant::int_value() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Variant.int_value) + return int_value_; +} +inline void Variant::set_int_value(::google::protobuf::int64 value) { + set_has_int_value(); + int_value_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.Variant.int_value) +} + +// optional double float_value = 4; +inline bool Variant::has_float_value() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void Variant::set_has_float_value() { + _has_bits_[0] |= 0x00000004u; +} +inline void Variant::clear_has_float_value() { + _has_bits_[0] &= ~0x00000004u; +} +inline void Variant::clear_float_value() { + float_value_ = 0; + clear_has_float_value(); +} +inline double Variant::float_value() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Variant.float_value) + return float_value_; +} +inline void Variant::set_float_value(double value) { + set_has_float_value(); + float_value_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.Variant.float_value) +} + +// optional string string_value = 5; +inline bool Variant::has_string_value() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void Variant::set_has_string_value() { + _has_bits_[0] |= 0x00000008u; +} +inline void Variant::clear_has_string_value() { + _has_bits_[0] &= ~0x00000008u; +} +inline void Variant::clear_string_value() { + if (string_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + string_value_->clear(); + } + clear_has_string_value(); +} +inline const ::std::string& Variant::string_value() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Variant.string_value) + return *string_value_; +} +inline void Variant::set_string_value(const ::std::string& value) { + set_has_string_value(); + if (string_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + string_value_ = new ::std::string; + } + string_value_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.Variant.string_value) +} +inline void Variant::set_string_value(const char* value) { + set_has_string_value(); + if (string_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + string_value_ = new ::std::string; + } + string_value_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.Variant.string_value) +} +inline void Variant::set_string_value(const char* value, size_t size) { + set_has_string_value(); + if (string_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + string_value_ = new ::std::string; + } + string_value_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.Variant.string_value) +} +inline ::std::string* Variant::mutable_string_value() { + set_has_string_value(); + if (string_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + string_value_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.Variant.string_value) + return string_value_; +} +inline ::std::string* Variant::release_string_value() { + clear_has_string_value(); + if (string_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = string_value_; + string_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void Variant::set_allocated_string_value(::std::string* string_value) { + if (string_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete string_value_; + } + if (string_value) { + set_has_string_value(); + string_value_ = string_value; + } else { + clear_has_string_value(); + string_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Variant.string_value) +} + +// optional bytes blob_value = 6; +inline bool Variant::has_blob_value() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void Variant::set_has_blob_value() { + _has_bits_[0] |= 0x00000010u; +} +inline void Variant::clear_has_blob_value() { + _has_bits_[0] &= ~0x00000010u; +} +inline void Variant::clear_blob_value() { + if (blob_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + blob_value_->clear(); + } + clear_has_blob_value(); +} +inline const ::std::string& Variant::blob_value() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Variant.blob_value) + return *blob_value_; +} +inline void Variant::set_blob_value(const ::std::string& value) { + set_has_blob_value(); + if (blob_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + blob_value_ = new ::std::string; + } + blob_value_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.Variant.blob_value) +} +inline void Variant::set_blob_value(const char* value) { + set_has_blob_value(); + if (blob_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + blob_value_ = new ::std::string; + } + blob_value_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.Variant.blob_value) +} +inline void Variant::set_blob_value(const void* value, size_t size) { + set_has_blob_value(); + if (blob_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + blob_value_ = new ::std::string; + } + blob_value_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.Variant.blob_value) +} +inline ::std::string* Variant::mutable_blob_value() { + set_has_blob_value(); + if (blob_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + blob_value_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.Variant.blob_value) + return blob_value_; +} +inline ::std::string* Variant::release_blob_value() { + clear_has_blob_value(); + if (blob_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = blob_value_; + blob_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void Variant::set_allocated_blob_value(::std::string* blob_value) { + if (blob_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete blob_value_; + } + if (blob_value) { + set_has_blob_value(); + blob_value_ = blob_value; + } else { + clear_has_blob_value(); + blob_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Variant.blob_value) +} + +// optional bytes message_value = 7; +inline bool Variant::has_message_value() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void Variant::set_has_message_value() { + _has_bits_[0] |= 0x00000020u; +} +inline void Variant::clear_has_message_value() { + _has_bits_[0] &= ~0x00000020u; +} +inline void Variant::clear_message_value() { + if (message_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + message_value_->clear(); + } + clear_has_message_value(); +} +inline const ::std::string& Variant::message_value() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Variant.message_value) + return *message_value_; +} +inline void Variant::set_message_value(const ::std::string& value) { + set_has_message_value(); + if (message_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + message_value_ = new ::std::string; + } + message_value_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.Variant.message_value) +} +inline void Variant::set_message_value(const char* value) { + set_has_message_value(); + if (message_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + message_value_ = new ::std::string; + } + message_value_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.Variant.message_value) +} +inline void Variant::set_message_value(const void* value, size_t size) { + set_has_message_value(); + if (message_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + message_value_ = new ::std::string; + } + message_value_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.Variant.message_value) +} +inline ::std::string* Variant::mutable_message_value() { + set_has_message_value(); + if (message_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + message_value_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.Variant.message_value) + return message_value_; +} +inline ::std::string* Variant::release_message_value() { + clear_has_message_value(); + if (message_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = message_value_; + message_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void Variant::set_allocated_message_value(::std::string* message_value) { + if (message_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete message_value_; + } + if (message_value) { + set_has_message_value(); + message_value_ = message_value; + } else { + clear_has_message_value(); + message_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Variant.message_value) +} + +// optional string fourcc_value = 8; +inline bool Variant::has_fourcc_value() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void Variant::set_has_fourcc_value() { + _has_bits_[0] |= 0x00000040u; +} +inline void Variant::clear_has_fourcc_value() { + _has_bits_[0] &= ~0x00000040u; +} +inline void Variant::clear_fourcc_value() { + if (fourcc_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + fourcc_value_->clear(); + } + clear_has_fourcc_value(); +} +inline const ::std::string& Variant::fourcc_value() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Variant.fourcc_value) + return *fourcc_value_; +} +inline void Variant::set_fourcc_value(const ::std::string& value) { + set_has_fourcc_value(); + if (fourcc_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + fourcc_value_ = new ::std::string; + } + fourcc_value_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.Variant.fourcc_value) +} +inline void Variant::set_fourcc_value(const char* value) { + set_has_fourcc_value(); + if (fourcc_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + fourcc_value_ = new ::std::string; + } + fourcc_value_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.Variant.fourcc_value) +} +inline void Variant::set_fourcc_value(const char* value, size_t size) { + set_has_fourcc_value(); + if (fourcc_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + fourcc_value_ = new ::std::string; + } + fourcc_value_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.Variant.fourcc_value) +} +inline ::std::string* Variant::mutable_fourcc_value() { + set_has_fourcc_value(); + if (fourcc_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + fourcc_value_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.Variant.fourcc_value) + return fourcc_value_; +} +inline ::std::string* Variant::release_fourcc_value() { + clear_has_fourcc_value(); + if (fourcc_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = fourcc_value_; + fourcc_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void Variant::set_allocated_fourcc_value(::std::string* fourcc_value) { + if (fourcc_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete fourcc_value_; + } + if (fourcc_value) { + set_has_fourcc_value(); + fourcc_value_ = fourcc_value; + } else { + clear_has_fourcc_value(); + fourcc_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Variant.fourcc_value) +} + +// optional uint64 uint_value = 9; +inline bool Variant::has_uint_value() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void Variant::set_has_uint_value() { + _has_bits_[0] |= 0x00000080u; +} +inline void Variant::clear_has_uint_value() { + _has_bits_[0] &= ~0x00000080u; +} +inline void Variant::clear_uint_value() { + uint_value_ = GOOGLE_ULONGLONG(0); + clear_has_uint_value(); +} +inline ::google::protobuf::uint64 Variant::uint_value() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Variant.uint_value) + return uint_value_; +} +inline void Variant::set_uint_value(::google::protobuf::uint64 value) { + set_has_uint_value(); + uint_value_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.Variant.uint_value) +} + +// optional .bgs.protocol.EntityId entity_id_value = 10; +inline bool Variant::has_entity_id_value() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void Variant::set_has_entity_id_value() { + _has_bits_[0] |= 0x00000100u; +} +inline void Variant::clear_has_entity_id_value() { + _has_bits_[0] &= ~0x00000100u; +} +inline void Variant::clear_entity_id_value() { + if (entity_id_value_ != NULL) entity_id_value_->::bgs::protocol::EntityId::Clear(); + clear_has_entity_id_value(); +} +inline const ::bgs::protocol::EntityId& Variant::entity_id_value() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Variant.entity_id_value) + return entity_id_value_ != NULL ? *entity_id_value_ : *default_instance_->entity_id_value_; +} +inline ::bgs::protocol::EntityId* Variant::mutable_entity_id_value() { + set_has_entity_id_value(); + if (entity_id_value_ == NULL) entity_id_value_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.Variant.entity_id_value) + return entity_id_value_; +} +inline ::bgs::protocol::EntityId* Variant::release_entity_id_value() { + clear_has_entity_id_value(); + ::bgs::protocol::EntityId* temp = entity_id_value_; + entity_id_value_ = NULL; + return temp; +} +inline void Variant::set_allocated_entity_id_value(::bgs::protocol::EntityId* entity_id_value) { + delete entity_id_value_; + entity_id_value_ = entity_id_value; + if (entity_id_value) { + set_has_entity_id_value(); + } else { + clear_has_entity_id_value(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Variant.entity_id_value) +} + +// ------------------------------------------------------------------- + +// Attribute + +// required string name = 1; +inline bool Attribute::has_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Attribute::set_has_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void Attribute::clear_has_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Attribute::clear_name() { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& Attribute::name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Attribute.name) + return *name_; +} +inline void Attribute::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.Attribute.name) +} +inline void Attribute::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.Attribute.name) +} +inline void Attribute::set_name(const char* value, size_t size) { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.Attribute.name) +} +inline ::std::string* Attribute::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.Attribute.name) + return name_; +} +inline ::std::string* Attribute::release_name() { + clear_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = name_; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void Attribute::set_allocated_name(::std::string* name) { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete name_; + } + if (name) { + set_has_name(); + name_ = name; + } else { + clear_has_name(); + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Attribute.name) +} + +// required .bgs.protocol.Variant value = 2; +inline bool Attribute::has_value() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Attribute::set_has_value() { + _has_bits_[0] |= 0x00000002u; +} +inline void Attribute::clear_has_value() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Attribute::clear_value() { + if (value_ != NULL) value_->::bgs::protocol::Variant::Clear(); + clear_has_value(); +} +inline const ::bgs::protocol::Variant& Attribute::value() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Attribute.value) + return value_ != NULL ? *value_ : *default_instance_->value_; +} +inline ::bgs::protocol::Variant* Attribute::mutable_value() { + set_has_value(); + if (value_ == NULL) value_ = new ::bgs::protocol::Variant; + // @@protoc_insertion_point(field_mutable:bgs.protocol.Attribute.value) + return value_; +} +inline ::bgs::protocol::Variant* Attribute::release_value() { + clear_has_value(); + ::bgs::protocol::Variant* temp = value_; + value_ = NULL; + return temp; +} +inline void Attribute::set_allocated_value(::bgs::protocol::Variant* value) { + delete value_; + value_ = value; + if (value) { + set_has_value(); + } else { + clear_has_value(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Attribute.value) +} + +// ------------------------------------------------------------------- + +// AttributeFilter + +// required .bgs.protocol.AttributeFilter.Operation op = 1; +inline bool AttributeFilter::has_op() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AttributeFilter::set_has_op() { + _has_bits_[0] |= 0x00000001u; +} +inline void AttributeFilter::clear_has_op() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AttributeFilter::clear_op() { + op_ = 0; + clear_has_op(); +} +inline ::bgs::protocol::AttributeFilter_Operation AttributeFilter::op() const { + // @@protoc_insertion_point(field_get:bgs.protocol.AttributeFilter.op) + return static_cast< ::bgs::protocol::AttributeFilter_Operation >(op_); +} +inline void AttributeFilter::set_op(::bgs::protocol::AttributeFilter_Operation value) { + assert(::bgs::protocol::AttributeFilter_Operation_IsValid(value)); + set_has_op(); + op_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.AttributeFilter.op) +} + +// repeated .bgs.protocol.Attribute attribute = 2; +inline int AttributeFilter::attribute_size() const { + return attribute_.size(); +} +inline void AttributeFilter::clear_attribute() { + attribute_.Clear(); +} +inline const ::bgs::protocol::Attribute& AttributeFilter::attribute(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.AttributeFilter.attribute) + return attribute_.Get(index); +} +inline ::bgs::protocol::Attribute* AttributeFilter::mutable_attribute(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.AttributeFilter.attribute) + return attribute_.Mutable(index); +} +inline ::bgs::protocol::Attribute* AttributeFilter::add_attribute() { + // @@protoc_insertion_point(field_add:bgs.protocol.AttributeFilter.attribute) + return attribute_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& +AttributeFilter::attribute() const { + // @@protoc_insertion_point(field_list:bgs.protocol.AttributeFilter.attribute) + return attribute_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* +AttributeFilter::mutable_attribute() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.AttributeFilter.attribute) + return &attribute_; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + +template <> struct is_proto_enum< ::bgs::protocol::AttributeFilter_Operation> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::AttributeFilter_Operation>() { + return ::bgs::protocol::AttributeFilter_Operation_descriptor(); +} + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_attribute_5ftypes_2eproto__INCLUDED diff --git a/src/server/proto/Client/authentication_service.pb.cc b/src/server/proto/Client/authentication_service.pb.cc new file mode 100644 index 00000000000..30998e348c7 --- /dev/null +++ b/src/server/proto/Client/authentication_service.pb.cc @@ -0,0 +1,7731 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: authentication_service.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "authentication_service.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +#include "BattlenetRpcErrorCodes.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { +namespace authentication { +namespace v1 { + +namespace { + +const ::google::protobuf::Descriptor* ModuleLoadRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ModuleLoadRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* ModuleNotification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ModuleNotification_reflection_ = NULL; +const ::google::protobuf::Descriptor* ModuleMessageRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ModuleMessageRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* LogonRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + LogonRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* LogonResult_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + LogonResult_reflection_ = NULL; +const ::google::protobuf::Descriptor* GenerateSSOTokenRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GenerateSSOTokenRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* GenerateSSOTokenResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GenerateSSOTokenResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* LogonUpdateRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + LogonUpdateRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* LogonQueueUpdateRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + LogonQueueUpdateRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* AccountSettingsNotification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AccountSettingsNotification_reflection_ = NULL; +const ::google::protobuf::Descriptor* ServerStateChangeRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ServerStateChangeRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* VersionInfo_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + VersionInfo_reflection_ = NULL; +const ::google::protobuf::Descriptor* VersionInfoNotification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + VersionInfoNotification_reflection_ = NULL; +const ::google::protobuf::Descriptor* MemModuleLoadRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + MemModuleLoadRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* MemModuleLoadResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + MemModuleLoadResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* SelectGameAccountRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SelectGameAccountRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* GameAccountSelectedRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GameAccountSelectedRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* GenerateWebCredentialsRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GenerateWebCredentialsRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* GenerateWebCredentialsResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GenerateWebCredentialsResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* VerifyWebCredentialsRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + VerifyWebCredentialsRequest_reflection_ = NULL; +const ::google::protobuf::ServiceDescriptor* AuthenticationListener_descriptor_ = NULL; +const ::google::protobuf::ServiceDescriptor* AuthenticationService_descriptor_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_authentication_5fservice_2eproto() { + protobuf_AddDesc_authentication_5fservice_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "authentication_service.proto"); + GOOGLE_CHECK(file != NULL); + ModuleLoadRequest_descriptor_ = file->message_type(0); + static const int ModuleLoadRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ModuleLoadRequest, module_handle_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ModuleLoadRequest, message_), + }; + ModuleLoadRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ModuleLoadRequest_descriptor_, + ModuleLoadRequest::default_instance_, + ModuleLoadRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ModuleLoadRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ModuleLoadRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ModuleLoadRequest)); + ModuleNotification_descriptor_ = file->message_type(1); + static const int ModuleNotification_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ModuleNotification, module_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ModuleNotification, result_), + }; + ModuleNotification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ModuleNotification_descriptor_, + ModuleNotification::default_instance_, + ModuleNotification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ModuleNotification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ModuleNotification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ModuleNotification)); + ModuleMessageRequest_descriptor_ = file->message_type(2); + static const int ModuleMessageRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ModuleMessageRequest, module_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ModuleMessageRequest, message_), + }; + ModuleMessageRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ModuleMessageRequest_descriptor_, + ModuleMessageRequest::default_instance_, + ModuleMessageRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ModuleMessageRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ModuleMessageRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ModuleMessageRequest)); + LogonRequest_descriptor_ = file->message_type(3); + static const int LogonRequest_offsets_[14] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, program_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, platform_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, locale_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, email_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, version_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, application_version_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, public_computer_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, sso_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, disconnect_on_cookie_fail_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, allow_logon_queue_notifications_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, web_client_verification_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, cached_web_credentials_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, enable_cookie_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, user_agent_), + }; + LogonRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + LogonRequest_descriptor_, + LogonRequest::default_instance_, + LogonRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(LogonRequest)); + LogonResult_descriptor_ = file->message_type(4); + static const int LogonResult_offsets_[10] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonResult, error_code_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonResult, account_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonResult, game_account_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonResult, email_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonResult, available_region_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonResult, connected_region_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonResult, battle_tag_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonResult, geoip_country_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonResult, session_key_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonResult, restricted_mode_), + }; + LogonResult_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + LogonResult_descriptor_, + LogonResult::default_instance_, + LogonResult_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonResult, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonResult, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(LogonResult)); + GenerateSSOTokenRequest_descriptor_ = file->message_type(5); + static const int GenerateSSOTokenRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateSSOTokenRequest, program_), + }; + GenerateSSOTokenRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GenerateSSOTokenRequest_descriptor_, + GenerateSSOTokenRequest::default_instance_, + GenerateSSOTokenRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateSSOTokenRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateSSOTokenRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GenerateSSOTokenRequest)); + GenerateSSOTokenResponse_descriptor_ = file->message_type(6); + static const int GenerateSSOTokenResponse_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateSSOTokenResponse, sso_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateSSOTokenResponse, sso_secret_), + }; + GenerateSSOTokenResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GenerateSSOTokenResponse_descriptor_, + GenerateSSOTokenResponse::default_instance_, + GenerateSSOTokenResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateSSOTokenResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateSSOTokenResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GenerateSSOTokenResponse)); + LogonUpdateRequest_descriptor_ = file->message_type(7); + static const int LogonUpdateRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonUpdateRequest, error_code_), + }; + LogonUpdateRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + LogonUpdateRequest_descriptor_, + LogonUpdateRequest::default_instance_, + LogonUpdateRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonUpdateRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonUpdateRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(LogonUpdateRequest)); + LogonQueueUpdateRequest_descriptor_ = file->message_type(8); + static const int LogonQueueUpdateRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonQueueUpdateRequest, position_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonQueueUpdateRequest, estimated_time_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonQueueUpdateRequest, eta_deviation_in_sec_), + }; + LogonQueueUpdateRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + LogonQueueUpdateRequest_descriptor_, + LogonQueueUpdateRequest::default_instance_, + LogonQueueUpdateRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonQueueUpdateRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonQueueUpdateRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(LogonQueueUpdateRequest)); + AccountSettingsNotification_descriptor_ = file->message_type(9); + static const int AccountSettingsNotification_offsets_[5] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountSettingsNotification, licenses_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountSettingsNotification, is_using_rid_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountSettingsNotification, is_playing_from_igr_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountSettingsNotification, can_receive_voice_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountSettingsNotification, can_send_voice_), + }; + AccountSettingsNotification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AccountSettingsNotification_descriptor_, + AccountSettingsNotification::default_instance_, + AccountSettingsNotification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountSettingsNotification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountSettingsNotification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AccountSettingsNotification)); + ServerStateChangeRequest_descriptor_ = file->message_type(10); + static const int ServerStateChangeRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerStateChangeRequest, state_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerStateChangeRequest, event_time_), + }; + ServerStateChangeRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ServerStateChangeRequest_descriptor_, + ServerStateChangeRequest::default_instance_, + ServerStateChangeRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerStateChangeRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerStateChangeRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ServerStateChangeRequest)); + VersionInfo_descriptor_ = file->message_type(11); + static const int VersionInfo_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VersionInfo, number_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VersionInfo, patch_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VersionInfo, is_optional_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VersionInfo, kick_time_), + }; + VersionInfo_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + VersionInfo_descriptor_, + VersionInfo::default_instance_, + VersionInfo_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VersionInfo, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VersionInfo, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(VersionInfo)); + VersionInfoNotification_descriptor_ = file->message_type(12); + static const int VersionInfoNotification_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VersionInfoNotification, version_info_), + }; + VersionInfoNotification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + VersionInfoNotification_descriptor_, + VersionInfoNotification::default_instance_, + VersionInfoNotification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VersionInfoNotification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VersionInfoNotification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(VersionInfoNotification)); + MemModuleLoadRequest_descriptor_ = file->message_type(13); + static const int MemModuleLoadRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemModuleLoadRequest, handle_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemModuleLoadRequest, key_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemModuleLoadRequest, input_), + }; + MemModuleLoadRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + MemModuleLoadRequest_descriptor_, + MemModuleLoadRequest::default_instance_, + MemModuleLoadRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemModuleLoadRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemModuleLoadRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(MemModuleLoadRequest)); + MemModuleLoadResponse_descriptor_ = file->message_type(14); + static const int MemModuleLoadResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemModuleLoadResponse, data_), + }; + MemModuleLoadResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + MemModuleLoadResponse_descriptor_, + MemModuleLoadResponse::default_instance_, + MemModuleLoadResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemModuleLoadResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemModuleLoadResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(MemModuleLoadResponse)); + SelectGameAccountRequest_descriptor_ = file->message_type(15); + static const int SelectGameAccountRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectGameAccountRequest, game_account_id_), + }; + SelectGameAccountRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + SelectGameAccountRequest_descriptor_, + SelectGameAccountRequest::default_instance_, + SelectGameAccountRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectGameAccountRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectGameAccountRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(SelectGameAccountRequest)); + GameAccountSelectedRequest_descriptor_ = file->message_type(16); + static const int GameAccountSelectedRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountSelectedRequest, result_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountSelectedRequest, game_account_id_), + }; + GameAccountSelectedRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GameAccountSelectedRequest_descriptor_, + GameAccountSelectedRequest::default_instance_, + GameAccountSelectedRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountSelectedRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountSelectedRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GameAccountSelectedRequest)); + GenerateWebCredentialsRequest_descriptor_ = file->message_type(17); + static const int GenerateWebCredentialsRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateWebCredentialsRequest, program_), + }; + GenerateWebCredentialsRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GenerateWebCredentialsRequest_descriptor_, + GenerateWebCredentialsRequest::default_instance_, + GenerateWebCredentialsRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateWebCredentialsRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateWebCredentialsRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GenerateWebCredentialsRequest)); + GenerateWebCredentialsResponse_descriptor_ = file->message_type(18); + static const int GenerateWebCredentialsResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateWebCredentialsResponse, web_credentials_), + }; + GenerateWebCredentialsResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GenerateWebCredentialsResponse_descriptor_, + GenerateWebCredentialsResponse::default_instance_, + GenerateWebCredentialsResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateWebCredentialsResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateWebCredentialsResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GenerateWebCredentialsResponse)); + VerifyWebCredentialsRequest_descriptor_ = file->message_type(19); + static const int VerifyWebCredentialsRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VerifyWebCredentialsRequest, web_credentials_), + }; + VerifyWebCredentialsRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + VerifyWebCredentialsRequest_descriptor_, + VerifyWebCredentialsRequest::default_instance_, + VerifyWebCredentialsRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VerifyWebCredentialsRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VerifyWebCredentialsRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(VerifyWebCredentialsRequest)); + AuthenticationListener_descriptor_ = file->service(0); + AuthenticationService_descriptor_ = file->service(1); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_authentication_5fservice_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ModuleLoadRequest_descriptor_, &ModuleLoadRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ModuleNotification_descriptor_, &ModuleNotification::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ModuleMessageRequest_descriptor_, &ModuleMessageRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + LogonRequest_descriptor_, &LogonRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + LogonResult_descriptor_, &LogonResult::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GenerateSSOTokenRequest_descriptor_, &GenerateSSOTokenRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GenerateSSOTokenResponse_descriptor_, &GenerateSSOTokenResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + LogonUpdateRequest_descriptor_, &LogonUpdateRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + LogonQueueUpdateRequest_descriptor_, &LogonQueueUpdateRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AccountSettingsNotification_descriptor_, &AccountSettingsNotification::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ServerStateChangeRequest_descriptor_, &ServerStateChangeRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + VersionInfo_descriptor_, &VersionInfo::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + VersionInfoNotification_descriptor_, &VersionInfoNotification::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + MemModuleLoadRequest_descriptor_, &MemModuleLoadRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + MemModuleLoadResponse_descriptor_, &MemModuleLoadResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SelectGameAccountRequest_descriptor_, &SelectGameAccountRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GameAccountSelectedRequest_descriptor_, &GameAccountSelectedRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GenerateWebCredentialsRequest_descriptor_, &GenerateWebCredentialsRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GenerateWebCredentialsResponse_descriptor_, &GenerateWebCredentialsResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + VerifyWebCredentialsRequest_descriptor_, &VerifyWebCredentialsRequest::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_authentication_5fservice_2eproto() { + delete ModuleLoadRequest::default_instance_; + delete ModuleLoadRequest_reflection_; + delete ModuleNotification::default_instance_; + delete ModuleNotification_reflection_; + delete ModuleMessageRequest::default_instance_; + delete ModuleMessageRequest_reflection_; + delete LogonRequest::default_instance_; + delete LogonRequest_reflection_; + delete LogonResult::default_instance_; + delete LogonResult_reflection_; + delete GenerateSSOTokenRequest::default_instance_; + delete GenerateSSOTokenRequest_reflection_; + delete GenerateSSOTokenResponse::default_instance_; + delete GenerateSSOTokenResponse_reflection_; + delete LogonUpdateRequest::default_instance_; + delete LogonUpdateRequest_reflection_; + delete LogonQueueUpdateRequest::default_instance_; + delete LogonQueueUpdateRequest_reflection_; + delete AccountSettingsNotification::default_instance_; + delete AccountSettingsNotification_reflection_; + delete ServerStateChangeRequest::default_instance_; + delete ServerStateChangeRequest_reflection_; + delete VersionInfo::default_instance_; + delete VersionInfo_reflection_; + delete VersionInfoNotification::default_instance_; + delete VersionInfoNotification_reflection_; + delete MemModuleLoadRequest::default_instance_; + delete MemModuleLoadRequest_reflection_; + delete MemModuleLoadResponse::default_instance_; + delete MemModuleLoadResponse_reflection_; + delete SelectGameAccountRequest::default_instance_; + delete SelectGameAccountRequest_reflection_; + delete GameAccountSelectedRequest::default_instance_; + delete GameAccountSelectedRequest_reflection_; + delete GenerateWebCredentialsRequest::default_instance_; + delete GenerateWebCredentialsRequest_reflection_; + delete GenerateWebCredentialsResponse::default_instance_; + delete GenerateWebCredentialsResponse_reflection_; + delete VerifyWebCredentialsRequest::default_instance_; + delete VerifyWebCredentialsRequest_reflection_; +} + +void protobuf_AddDesc_authentication_5fservice_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::bgs::protocol::account::v1::protobuf_AddDesc_account_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_content_5fhandle_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\034authentication_service.proto\022\036bgs.prot" + "ocol.authentication.v1\032\023account_types.pr" + "oto\032\032content_handle_types.proto\032\022entity_" + "types.proto\032\017rpc_types.proto\"X\n\021ModuleLo" + "adRequest\0222\n\rmodule_handle\030\001 \002(\0132\033.bgs.p" + "rotocol.ContentHandle\022\017\n\007message\030\002 \001(\014\"7" + "\n\022ModuleNotification\022\021\n\tmodule_id\030\002 \001(\005\022" + "\016\n\006result\030\003 \001(\r\":\n\024ModuleMessageRequest\022" + "\021\n\tmodule_id\030\001 \002(\005\022\017\n\007message\030\002 \001(\014\"\372\002\n\014" + "LogonRequest\022\017\n\007program\030\001 \001(\t\022\020\n\010platfor" + "m\030\002 \001(\t\022\016\n\006locale\030\003 \001(\t\022\r\n\005email\030\004 \001(\t\022\017" + "\n\007version\030\005 \001(\t\022\033\n\023application_version\030\006" + " \001(\005\022\027\n\017public_computer\030\007 \001(\010\022\016\n\006sso_id\030" + "\010 \001(\014\022(\n\031disconnect_on_cookie_fail\030\t \001(\010" + ":\005false\022.\n\037allow_logon_queue_notificatio" + "ns\030\n \001(\010:\005false\022&\n\027web_client_verificati" + "on\030\013 \001(\010:\005false\022\036\n\026cached_web_credential" + "s\030\014 \001(\014\022\033\n\renable_cookie\030\r \001(\010:\004true\022\022\n\n" + "user_agent\030\016 \001(\t\"\232\002\n\013LogonResult\022\022\n\nerro" + "r_code\030\001 \002(\r\022*\n\naccount_id\030\002 \001(\0132\026.bgs.p" + "rotocol.EntityId\022/\n\017game_account_id\030\003 \003(" + "\0132\026.bgs.protocol.EntityId\022\r\n\005email\030\004 \001(\t" + "\022\030\n\020available_region\030\005 \003(\r\022\030\n\020connected_" + "region\030\006 \001(\r\022\022\n\nbattle_tag\030\007 \001(\t\022\025\n\rgeoi" + "p_country\030\010 \001(\t\022\023\n\013session_key\030\t \001(\014\022\027\n\017" + "restricted_mode\030\n \001(\010\"*\n\027GenerateSSOToke" + "nRequest\022\017\n\007program\030\001 \001(\007\">\n\030GenerateSSO" + "TokenResponse\022\016\n\006sso_id\030\001 \001(\014\022\022\n\nsso_sec" + "ret\030\002 \001(\014\"(\n\022LogonUpdateRequest\022\022\n\nerror" + "_code\030\001 \002(\r\"a\n\027LogonQueueUpdateRequest\022\020" + "\n\010position\030\001 \002(\r\022\026\n\016estimated_time\030\002 \002(\004" + "\022\034\n\024eta_deviation_in_sec\030\003 \002(\004\"\276\001\n\033Accou" + "ntSettingsNotification\0229\n\010licenses\030\001 \003(\013" + "2\'.bgs.protocol.account.v1.AccountLicens" + "e\022\024\n\014is_using_rid\030\002 \001(\010\022\033\n\023is_playing_fr" + "om_igr\030\003 \001(\010\022\031\n\021can_receive_voice\030\004 \001(\010\022" + "\026\n\016can_send_voice\030\005 \001(\010\"=\n\030ServerStateCh" + "angeRequest\022\r\n\005state\030\001 \002(\r\022\022\n\nevent_time" + "\030\002 \002(\004\"T\n\013VersionInfo\022\016\n\006number\030\001 \001(\r\022\r\n" + "\005patch\030\002 \001(\t\022\023\n\013is_optional\030\003 \001(\010\022\021\n\tkic" + "k_time\030\004 \001(\004\"\\\n\027VersionInfoNotification\022" + "A\n\014version_info\030\001 \001(\0132+.bgs.protocol.aut" + "hentication.v1.VersionInfo\"_\n\024MemModuleL" + "oadRequest\022+\n\006handle\030\001 \002(\0132\033.bgs.protoco" + "l.ContentHandle\022\013\n\003key\030\002 \002(\014\022\r\n\005input\030\003 " + "\002(\014\"%\n\025MemModuleLoadResponse\022\014\n\004data\030\001 \002" + "(\014\"K\n\030SelectGameAccountRequest\022/\n\017game_a" + "ccount_id\030\001 \002(\0132\026.bgs.protocol.EntityId\"" + "]\n\032GameAccountSelectedRequest\022\016\n\006result\030" + "\001 \002(\r\022/\n\017game_account_id\030\002 \001(\0132\026.bgs.pro" + "tocol.EntityId\"0\n\035GenerateWebCredentials" + "Request\022\017\n\007program\030\001 \001(\007\"9\n\036GenerateWebC" + "redentialsResponse\022\027\n\017web_credentials\030\001 " + "\001(\014\"6\n\033VerifyWebCredentialsRequest\022\027\n\017we" + "b_credentials\030\001 \001(\0142\202\t\n\026AuthenticationLi" + "stener\022e\n\014OnModuleLoad\0221.bgs.protocol.au" + "thentication.v1.ModuleLoadRequest\032\031.bgs." + "protocol.NO_RESPONSE\"\007\210\002\001\200\265\030\001\022f\n\017OnModul" + "eMessage\0224.bgs.protocol.authentication.v" + "1.ModuleMessageRequest\032\024.bgs.protocol.No" + "Data\"\007\210\002\001\200\265\030\002\022p\n\023OnServerStateChange\0228.b" + "gs.protocol.authentication.v1.ServerStat" + "eChangeRequest\032\031.bgs.protocol.NO_RESPONS" + "E\"\004\200\265\030\004\022_\n\017OnLogonComplete\022+.bgs.protoco" + "l.authentication.v1.LogonResult\032\031.bgs.pr" + "otocol.NO_RESPONSE\"\004\200\265\030\005\022\204\001\n\017OnMemModule" + "Load\0224.bgs.protocol.authentication.v1.Me" + "mModuleLoadRequest\0325.bgs.protocol.authen" + "tication.v1.MemModuleLoadResponse\"\004\200\265\030\006\022" + "d\n\rOnLogonUpdate\0222.bgs.protocol.authenti" + "cation.v1.LogonUpdateRequest\032\031.bgs.proto" + "col.NO_RESPONSE\"\004\200\265\030\n\022p\n\024OnVersionInfoUp" + "dated\0227.bgs.protocol.authentication.v1.V" + "ersionInfoNotification\032\031.bgs.protocol.NO" + "_RESPONSE\"\004\200\265\030\013\022n\n\022OnLogonQueueUpdate\0227." + "bgs.protocol.authentication.v1.LogonQueu" + "eUpdateRequest\032\031.bgs.protocol.NO_RESPONS" + "E\"\004\200\265\030\014\022H\n\017OnLogonQueueEnd\022\024.bgs.protoco" + "l.NoData\032\031.bgs.protocol.NO_RESPONSE\"\004\200\265\030" + "\r\022w\n\025OnGameAccountSelected\022:.bgs.protoco" + "l.authentication.v1.GameAccountSelectedR" + "equest\032\031.bgs.protocol.NO_RESPONSE\"\007\210\002\001\200\265" + "\030\016\0324\312>1bnet.protocol.authentication.Auth" + "enticationClient2\315\007\n\025AuthenticationServi" + "ce\022Q\n\005Logon\022,.bgs.protocol.authenticatio" + "n.v1.LogonRequest\032\024.bgs.protocol.NoData\"" + "\004\200\265\030\001\022a\n\014ModuleNotify\0222.bgs.protocol.aut" + "hentication.v1.ModuleNotification\032\024.bgs." + "protocol.NoData\"\007\210\002\001\200\265\030\002\022d\n\rModuleMessag" + "e\0224.bgs.protocol.authentication.v1.Modul" + "eMessageRequest\032\024.bgs.protocol.NoData\"\007\210" + "\002\001\200\265\030\003\022U\n\034SelectGameAccount_DEPRECATED\022\026" + ".bgs.protocol.EntityId\032\024.bgs.protocol.No" + "Data\"\007\210\002\001\200\265\030\004\022\213\001\n\020GenerateSSOToken\0227.bgs" + ".protocol.authentication.v1.GenerateSSOT" + "okenRequest\0328.bgs.protocol.authenticatio" + "n.v1.GenerateSSOTokenResponse\"\004\200\265\030\005\022l\n\021S" + "electGameAccount\0228.bgs.protocol.authenti" + "cation.v1.SelectGameAccountRequest\032\024.bgs" + ".protocol.NoData\"\007\210\002\001\200\265\030\006\022o\n\024VerifyWebCr" + "edentials\022;.bgs.protocol.authentication." + "v1.VerifyWebCredentialsRequest\032\024.bgs.pro" + "tocol.NoData\"\004\200\265\030\007\022\235\001\n\026GenerateWebCreden" + "tials\022=.bgs.protocol.authentication.v1.G" + "enerateWebCredentialsRequest\032>.bgs.proto" + "col.authentication.v1.GenerateWebCredent" + "ialsResponse\"\004\200\265\030\010\0324\312>1bnet.protocol.aut" + "hentication.AuthenticationServerB\005H\001\200\001\000", 4319); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "authentication_service.proto", &protobuf_RegisterTypes); + ModuleLoadRequest::default_instance_ = new ModuleLoadRequest(); + ModuleNotification::default_instance_ = new ModuleNotification(); + ModuleMessageRequest::default_instance_ = new ModuleMessageRequest(); + LogonRequest::default_instance_ = new LogonRequest(); + LogonResult::default_instance_ = new LogonResult(); + GenerateSSOTokenRequest::default_instance_ = new GenerateSSOTokenRequest(); + GenerateSSOTokenResponse::default_instance_ = new GenerateSSOTokenResponse(); + LogonUpdateRequest::default_instance_ = new LogonUpdateRequest(); + LogonQueueUpdateRequest::default_instance_ = new LogonQueueUpdateRequest(); + AccountSettingsNotification::default_instance_ = new AccountSettingsNotification(); + ServerStateChangeRequest::default_instance_ = new ServerStateChangeRequest(); + VersionInfo::default_instance_ = new VersionInfo(); + VersionInfoNotification::default_instance_ = new VersionInfoNotification(); + MemModuleLoadRequest::default_instance_ = new MemModuleLoadRequest(); + MemModuleLoadResponse::default_instance_ = new MemModuleLoadResponse(); + SelectGameAccountRequest::default_instance_ = new SelectGameAccountRequest(); + GameAccountSelectedRequest::default_instance_ = new GameAccountSelectedRequest(); + GenerateWebCredentialsRequest::default_instance_ = new GenerateWebCredentialsRequest(); + GenerateWebCredentialsResponse::default_instance_ = new GenerateWebCredentialsResponse(); + VerifyWebCredentialsRequest::default_instance_ = new VerifyWebCredentialsRequest(); + ModuleLoadRequest::default_instance_->InitAsDefaultInstance(); + ModuleNotification::default_instance_->InitAsDefaultInstance(); + ModuleMessageRequest::default_instance_->InitAsDefaultInstance(); + LogonRequest::default_instance_->InitAsDefaultInstance(); + LogonResult::default_instance_->InitAsDefaultInstance(); + GenerateSSOTokenRequest::default_instance_->InitAsDefaultInstance(); + GenerateSSOTokenResponse::default_instance_->InitAsDefaultInstance(); + LogonUpdateRequest::default_instance_->InitAsDefaultInstance(); + LogonQueueUpdateRequest::default_instance_->InitAsDefaultInstance(); + AccountSettingsNotification::default_instance_->InitAsDefaultInstance(); + ServerStateChangeRequest::default_instance_->InitAsDefaultInstance(); + VersionInfo::default_instance_->InitAsDefaultInstance(); + VersionInfoNotification::default_instance_->InitAsDefaultInstance(); + MemModuleLoadRequest::default_instance_->InitAsDefaultInstance(); + MemModuleLoadResponse::default_instance_->InitAsDefaultInstance(); + SelectGameAccountRequest::default_instance_->InitAsDefaultInstance(); + GameAccountSelectedRequest::default_instance_->InitAsDefaultInstance(); + GenerateWebCredentialsRequest::default_instance_->InitAsDefaultInstance(); + GenerateWebCredentialsResponse::default_instance_->InitAsDefaultInstance(); + VerifyWebCredentialsRequest::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_authentication_5fservice_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_authentication_5fservice_2eproto { + StaticDescriptorInitializer_authentication_5fservice_2eproto() { + protobuf_AddDesc_authentication_5fservice_2eproto(); + } +} static_descriptor_initializer_authentication_5fservice_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int ModuleLoadRequest::kModuleHandleFieldNumber; +const int ModuleLoadRequest::kMessageFieldNumber; +#endif // !_MSC_VER + +ModuleLoadRequest::ModuleLoadRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.ModuleLoadRequest) +} + +void ModuleLoadRequest::InitAsDefaultInstance() { + module_handle_ = const_cast< ::bgs::protocol::ContentHandle*>(&::bgs::protocol::ContentHandle::default_instance()); +} + +ModuleLoadRequest::ModuleLoadRequest(const ModuleLoadRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.ModuleLoadRequest) +} + +void ModuleLoadRequest::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + module_handle_ = NULL; + message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ModuleLoadRequest::~ModuleLoadRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.ModuleLoadRequest) + SharedDtor(); +} + +void ModuleLoadRequest::SharedDtor() { + if (message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete message_; + } + if (this != default_instance_) { + delete module_handle_; + } +} + +void ModuleLoadRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ModuleLoadRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ModuleLoadRequest_descriptor_; +} + +const ModuleLoadRequest& ModuleLoadRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto(); + return *default_instance_; +} + +ModuleLoadRequest* ModuleLoadRequest::default_instance_ = NULL; + +ModuleLoadRequest* ModuleLoadRequest::New() const { + return new ModuleLoadRequest; +} + +void ModuleLoadRequest::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_module_handle()) { + if (module_handle_ != NULL) module_handle_->::bgs::protocol::ContentHandle::Clear(); + } + if (has_message()) { + if (message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + message_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ModuleLoadRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.ModuleLoadRequest) + 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)) { + // required .bgs.protocol.ContentHandle module_handle = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_module_handle())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_message; + break; + } + + // optional bytes message = 2; + case 2: { + if (tag == 18) { + parse_message: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_message())); + } 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:bgs.protocol.authentication.v1.ModuleLoadRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.ModuleLoadRequest) + return false; +#undef DO_ +} + +void ModuleLoadRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.ModuleLoadRequest) + // required .bgs.protocol.ContentHandle module_handle = 1; + if (has_module_handle()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->module_handle(), output); + } + + // optional bytes message = 2; + if (has_message()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 2, this->message(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.ModuleLoadRequest) +} + +::google::protobuf::uint8* ModuleLoadRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.ModuleLoadRequest) + // required .bgs.protocol.ContentHandle module_handle = 1; + if (has_module_handle()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->module_handle(), target); + } + + // optional bytes message = 2; + if (has_message()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 2, this->message(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.ModuleLoadRequest) + return target; +} + +int ModuleLoadRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.ContentHandle module_handle = 1; + if (has_module_handle()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->module_handle()); + } + + // optional bytes message = 2; + if (has_message()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->message()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ModuleLoadRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ModuleLoadRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ModuleLoadRequest::MergeFrom(const ModuleLoadRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_module_handle()) { + mutable_module_handle()->::bgs::protocol::ContentHandle::MergeFrom(from.module_handle()); + } + if (from.has_message()) { + set_message(from.message()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ModuleLoadRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ModuleLoadRequest::CopyFrom(const ModuleLoadRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ModuleLoadRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_module_handle()) { + if (!this->module_handle().IsInitialized()) return false; + } + return true; +} + +void ModuleLoadRequest::Swap(ModuleLoadRequest* other) { + if (other != this) { + std::swap(module_handle_, other->module_handle_); + std::swap(message_, other->message_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata ModuleLoadRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ModuleLoadRequest_descriptor_; + metadata.reflection = ModuleLoadRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ModuleNotification::kModuleIdFieldNumber; +const int ModuleNotification::kResultFieldNumber; +#endif // !_MSC_VER + +ModuleNotification::ModuleNotification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.ModuleNotification) +} + +void ModuleNotification::InitAsDefaultInstance() { +} + +ModuleNotification::ModuleNotification(const ModuleNotification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.ModuleNotification) +} + +void ModuleNotification::SharedCtor() { + _cached_size_ = 0; + module_id_ = 0; + result_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ModuleNotification::~ModuleNotification() { + // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.ModuleNotification) + SharedDtor(); +} + +void ModuleNotification::SharedDtor() { + if (this != default_instance_) { + } +} + +void ModuleNotification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ModuleNotification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ModuleNotification_descriptor_; +} + +const ModuleNotification& ModuleNotification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto(); + return *default_instance_; +} + +ModuleNotification* ModuleNotification::default_instance_ = NULL; + +ModuleNotification* ModuleNotification::New() const { + return new ModuleNotification; +} + +void ModuleNotification::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(module_id_, result_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ModuleNotification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.ModuleNotification) + 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 module_id = 2; + case 2: { + if (tag == 16) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &module_id_))); + set_has_module_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_result; + break; + } + + // optional uint32 result = 3; + case 3: { + if (tag == 24) { + parse_result: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &result_))); + set_has_result(); + } 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:bgs.protocol.authentication.v1.ModuleNotification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.ModuleNotification) + return false; +#undef DO_ +} + +void ModuleNotification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.ModuleNotification) + // optional int32 module_id = 2; + if (has_module_id()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->module_id(), output); + } + + // optional uint32 result = 3; + if (has_result()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->result(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.ModuleNotification) +} + +::google::protobuf::uint8* ModuleNotification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.ModuleNotification) + // optional int32 module_id = 2; + if (has_module_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->module_id(), target); + } + + // optional uint32 result = 3; + if (has_result()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->result(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.ModuleNotification) + return target; +} + +int ModuleNotification::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional int32 module_id = 2; + if (has_module_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->module_id()); + } + + // optional uint32 result = 3; + if (has_result()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->result()); + } + + } + 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 ModuleNotification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ModuleNotification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ModuleNotification::MergeFrom(const ModuleNotification& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_module_id()) { + set_module_id(from.module_id()); + } + if (from.has_result()) { + set_result(from.result()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ModuleNotification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ModuleNotification::CopyFrom(const ModuleNotification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ModuleNotification::IsInitialized() const { + + return true; +} + +void ModuleNotification::Swap(ModuleNotification* other) { + if (other != this) { + std::swap(module_id_, other->module_id_); + std::swap(result_, other->result_); + 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 ModuleNotification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ModuleNotification_descriptor_; + metadata.reflection = ModuleNotification_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ModuleMessageRequest::kModuleIdFieldNumber; +const int ModuleMessageRequest::kMessageFieldNumber; +#endif // !_MSC_VER + +ModuleMessageRequest::ModuleMessageRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.ModuleMessageRequest) +} + +void ModuleMessageRequest::InitAsDefaultInstance() { +} + +ModuleMessageRequest::ModuleMessageRequest(const ModuleMessageRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.ModuleMessageRequest) +} + +void ModuleMessageRequest::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + module_id_ = 0; + message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ModuleMessageRequest::~ModuleMessageRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.ModuleMessageRequest) + SharedDtor(); +} + +void ModuleMessageRequest::SharedDtor() { + if (message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete message_; + } + if (this != default_instance_) { + } +} + +void ModuleMessageRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ModuleMessageRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ModuleMessageRequest_descriptor_; +} + +const ModuleMessageRequest& ModuleMessageRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto(); + return *default_instance_; +} + +ModuleMessageRequest* ModuleMessageRequest::default_instance_ = NULL; + +ModuleMessageRequest* ModuleMessageRequest::New() const { + return new ModuleMessageRequest; +} + +void ModuleMessageRequest::Clear() { + if (_has_bits_[0 / 32] & 3) { + module_id_ = 0; + if (has_message()) { + if (message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + message_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ModuleMessageRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.ModuleMessageRequest) + 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)) { + // required int32 module_id = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &module_id_))); + set_has_module_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_message; + break; + } + + // optional bytes message = 2; + case 2: { + if (tag == 18) { + parse_message: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_message())); + } 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:bgs.protocol.authentication.v1.ModuleMessageRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.ModuleMessageRequest) + return false; +#undef DO_ +} + +void ModuleMessageRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.ModuleMessageRequest) + // required int32 module_id = 1; + if (has_module_id()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->module_id(), output); + } + + // optional bytes message = 2; + if (has_message()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 2, this->message(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.ModuleMessageRequest) +} + +::google::protobuf::uint8* ModuleMessageRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.ModuleMessageRequest) + // required int32 module_id = 1; + if (has_module_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->module_id(), target); + } + + // optional bytes message = 2; + if (has_message()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 2, this->message(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.ModuleMessageRequest) + return target; +} + +int ModuleMessageRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required int32 module_id = 1; + if (has_module_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->module_id()); + } + + // optional bytes message = 2; + if (has_message()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->message()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ModuleMessageRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ModuleMessageRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ModuleMessageRequest::MergeFrom(const ModuleMessageRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_module_id()) { + set_module_id(from.module_id()); + } + if (from.has_message()) { + set_message(from.message()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ModuleMessageRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ModuleMessageRequest::CopyFrom(const ModuleMessageRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ModuleMessageRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void ModuleMessageRequest::Swap(ModuleMessageRequest* other) { + if (other != this) { + std::swap(module_id_, other->module_id_); + std::swap(message_, other->message_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata ModuleMessageRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ModuleMessageRequest_descriptor_; + metadata.reflection = ModuleMessageRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int LogonRequest::kProgramFieldNumber; +const int LogonRequest::kPlatformFieldNumber; +const int LogonRequest::kLocaleFieldNumber; +const int LogonRequest::kEmailFieldNumber; +const int LogonRequest::kVersionFieldNumber; +const int LogonRequest::kApplicationVersionFieldNumber; +const int LogonRequest::kPublicComputerFieldNumber; +const int LogonRequest::kSsoIdFieldNumber; +const int LogonRequest::kDisconnectOnCookieFailFieldNumber; +const int LogonRequest::kAllowLogonQueueNotificationsFieldNumber; +const int LogonRequest::kWebClientVerificationFieldNumber; +const int LogonRequest::kCachedWebCredentialsFieldNumber; +const int LogonRequest::kEnableCookieFieldNumber; +const int LogonRequest::kUserAgentFieldNumber; +#endif // !_MSC_VER + +LogonRequest::LogonRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.LogonRequest) +} + +void LogonRequest::InitAsDefaultInstance() { +} + +LogonRequest::LogonRequest(const LogonRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.LogonRequest) +} + +void LogonRequest::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + program_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + platform_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + locale_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + application_version_ = 0; + public_computer_ = false; + sso_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + disconnect_on_cookie_fail_ = false; + allow_logon_queue_notifications_ = false; + web_client_verification_ = false; + cached_web_credentials_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + enable_cookie_ = true; + user_agent_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +LogonRequest::~LogonRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.LogonRequest) + SharedDtor(); +} + +void LogonRequest::SharedDtor() { + if (program_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete program_; + } + if (platform_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete platform_; + } + if (locale_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete locale_; + } + if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete email_; + } + if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete version_; + } + if (sso_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete sso_id_; + } + if (cached_web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete cached_web_credentials_; + } + if (user_agent_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete user_agent_; + } + if (this != default_instance_) { + } +} + +void LogonRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* LogonRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return LogonRequest_descriptor_; +} + +const LogonRequest& LogonRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto(); + return *default_instance_; +} + +LogonRequest* LogonRequest::default_instance_ = NULL; + +LogonRequest* LogonRequest::New() const { + return new LogonRequest; +} + +void LogonRequest::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(application_version_, public_computer_); + if (has_program()) { + if (program_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + program_->clear(); + } + } + if (has_platform()) { + if (platform_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + platform_->clear(); + } + } + if (has_locale()) { + if (locale_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + locale_->clear(); + } + } + if (has_email()) { + if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_->clear(); + } + } + if (has_version()) { + if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + version_->clear(); + } + } + if (has_sso_id()) { + if (sso_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sso_id_->clear(); + } + } + } + if (_has_bits_[8 / 32] & 16128) { + ZR_(disconnect_on_cookie_fail_, web_client_verification_); + if (has_cached_web_credentials()) { + if (cached_web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + cached_web_credentials_->clear(); + } + } + enable_cookie_ = true; + if (has_user_agent()) { + if (user_agent_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + user_agent_->clear(); + } + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool LogonRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.LogonRequest) + 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 program = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_program())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->program().data(), this->program().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "program"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_platform; + break; + } + + // optional string platform = 2; + case 2: { + if (tag == 18) { + parse_platform: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_platform())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->platform().data(), this->platform().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "platform"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_locale; + break; + } + + // optional string locale = 3; + case 3: { + if (tag == 26) { + parse_locale: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_locale())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->locale().data(), this->locale().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "locale"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_email; + break; + } + + // optional string email = 4; + case 4: { + if (tag == 34) { + parse_email: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_email())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->email().data(), this->email().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "email"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_version; + break; + } + + // optional string version = 5; + case 5: { + if (tag == 42) { + parse_version: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_version())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->version().data(), this->version().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "version"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_application_version; + break; + } + + // optional int32 application_version = 6; + case 6: { + if (tag == 48) { + parse_application_version: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &application_version_))); + set_has_application_version(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(56)) goto parse_public_computer; + break; + } + + // optional bool public_computer = 7; + case 7: { + if (tag == 56) { + parse_public_computer: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &public_computer_))); + set_has_public_computer(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(66)) goto parse_sso_id; + break; + } + + // optional bytes sso_id = 8; + case 8: { + if (tag == 66) { + parse_sso_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_sso_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(72)) goto parse_disconnect_on_cookie_fail; + break; + } + + // optional bool disconnect_on_cookie_fail = 9 [default = false]; + case 9: { + if (tag == 72) { + parse_disconnect_on_cookie_fail: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &disconnect_on_cookie_fail_))); + set_has_disconnect_on_cookie_fail(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(80)) goto parse_allow_logon_queue_notifications; + break; + } + + // optional bool allow_logon_queue_notifications = 10 [default = false]; + case 10: { + if (tag == 80) { + parse_allow_logon_queue_notifications: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &allow_logon_queue_notifications_))); + set_has_allow_logon_queue_notifications(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(88)) goto parse_web_client_verification; + break; + } + + // optional bool web_client_verification = 11 [default = false]; + case 11: { + if (tag == 88) { + parse_web_client_verification: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &web_client_verification_))); + set_has_web_client_verification(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(98)) goto parse_cached_web_credentials; + break; + } + + // optional bytes cached_web_credentials = 12; + case 12: { + if (tag == 98) { + parse_cached_web_credentials: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_cached_web_credentials())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(104)) goto parse_enable_cookie; + break; + } + + // optional bool enable_cookie = 13 [default = true]; + case 13: { + if (tag == 104) { + parse_enable_cookie: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &enable_cookie_))); + set_has_enable_cookie(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(114)) goto parse_user_agent; + break; + } + + // optional string user_agent = 14; + case 14: { + if (tag == 114) { + parse_user_agent: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_user_agent())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->user_agent().data(), this->user_agent().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "user_agent"); + } 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:bgs.protocol.authentication.v1.LogonRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.LogonRequest) + return false; +#undef DO_ +} + +void LogonRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.LogonRequest) + // optional string program = 1; + if (has_program()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->program().data(), this->program().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "program"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->program(), output); + } + + // optional string platform = 2; + if (has_platform()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->platform().data(), this->platform().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "platform"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->platform(), output); + } + + // optional string locale = 3; + if (has_locale()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->locale().data(), this->locale().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "locale"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->locale(), output); + } + + // optional string email = 4; + if (has_email()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->email().data(), this->email().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "email"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 4, this->email(), output); + } + + // optional string version = 5; + if (has_version()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->version().data(), this->version().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "version"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 5, this->version(), output); + } + + // optional int32 application_version = 6; + if (has_application_version()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->application_version(), output); + } + + // optional bool public_computer = 7; + if (has_public_computer()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->public_computer(), output); + } + + // optional bytes sso_id = 8; + if (has_sso_id()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 8, this->sso_id(), output); + } + + // optional bool disconnect_on_cookie_fail = 9 [default = false]; + if (has_disconnect_on_cookie_fail()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(9, this->disconnect_on_cookie_fail(), output); + } + + // optional bool allow_logon_queue_notifications = 10 [default = false]; + if (has_allow_logon_queue_notifications()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(10, this->allow_logon_queue_notifications(), output); + } + + // optional bool web_client_verification = 11 [default = false]; + if (has_web_client_verification()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(11, this->web_client_verification(), output); + } + + // optional bytes cached_web_credentials = 12; + if (has_cached_web_credentials()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 12, this->cached_web_credentials(), output); + } + + // optional bool enable_cookie = 13 [default = true]; + if (has_enable_cookie()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(13, this->enable_cookie(), output); + } + + // optional string user_agent = 14; + if (has_user_agent()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->user_agent().data(), this->user_agent().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "user_agent"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 14, this->user_agent(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.LogonRequest) +} + +::google::protobuf::uint8* LogonRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.LogonRequest) + // optional string program = 1; + if (has_program()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->program().data(), this->program().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "program"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->program(), target); + } + + // optional string platform = 2; + if (has_platform()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->platform().data(), this->platform().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "platform"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->platform(), target); + } + + // optional string locale = 3; + if (has_locale()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->locale().data(), this->locale().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "locale"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->locale(), target); + } + + // optional string email = 4; + if (has_email()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->email().data(), this->email().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "email"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->email(), target); + } + + // optional string version = 5; + if (has_version()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->version().data(), this->version().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "version"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 5, this->version(), target); + } + + // optional int32 application_version = 6; + if (has_application_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->application_version(), target); + } + + // optional bool public_computer = 7; + if (has_public_computer()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->public_computer(), target); + } + + // optional bytes sso_id = 8; + if (has_sso_id()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 8, this->sso_id(), target); + } + + // optional bool disconnect_on_cookie_fail = 9 [default = false]; + if (has_disconnect_on_cookie_fail()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(9, this->disconnect_on_cookie_fail(), target); + } + + // optional bool allow_logon_queue_notifications = 10 [default = false]; + if (has_allow_logon_queue_notifications()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(10, this->allow_logon_queue_notifications(), target); + } + + // optional bool web_client_verification = 11 [default = false]; + if (has_web_client_verification()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(11, this->web_client_verification(), target); + } + + // optional bytes cached_web_credentials = 12; + if (has_cached_web_credentials()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 12, this->cached_web_credentials(), target); + } + + // optional bool enable_cookie = 13 [default = true]; + if (has_enable_cookie()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(13, this->enable_cookie(), target); + } + + // optional string user_agent = 14; + if (has_user_agent()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->user_agent().data(), this->user_agent().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "user_agent"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 14, this->user_agent(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.LogonRequest) + return target; +} + +int LogonRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional string program = 1; + if (has_program()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->program()); + } + + // optional string platform = 2; + if (has_platform()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->platform()); + } + + // optional string locale = 3; + if (has_locale()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->locale()); + } + + // optional string email = 4; + if (has_email()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->email()); + } + + // optional string version = 5; + if (has_version()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->version()); + } + + // optional int32 application_version = 6; + if (has_application_version()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->application_version()); + } + + // optional bool public_computer = 7; + if (has_public_computer()) { + total_size += 1 + 1; + } + + // optional bytes sso_id = 8; + if (has_sso_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->sso_id()); + } + + } + if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + // optional bool disconnect_on_cookie_fail = 9 [default = false]; + if (has_disconnect_on_cookie_fail()) { + total_size += 1 + 1; + } + + // optional bool allow_logon_queue_notifications = 10 [default = false]; + if (has_allow_logon_queue_notifications()) { + total_size += 1 + 1; + } + + // optional bool web_client_verification = 11 [default = false]; + if (has_web_client_verification()) { + total_size += 1 + 1; + } + + // optional bytes cached_web_credentials = 12; + if (has_cached_web_credentials()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->cached_web_credentials()); + } + + // optional bool enable_cookie = 13 [default = true]; + if (has_enable_cookie()) { + total_size += 1 + 1; + } + + // optional string user_agent = 14; + if (has_user_agent()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->user_agent()); + } + + } + 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 LogonRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const LogonRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void LogonRequest::MergeFrom(const LogonRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_program()) { + set_program(from.program()); + } + if (from.has_platform()) { + set_platform(from.platform()); + } + if (from.has_locale()) { + set_locale(from.locale()); + } + if (from.has_email()) { + set_email(from.email()); + } + if (from.has_version()) { + set_version(from.version()); + } + if (from.has_application_version()) { + set_application_version(from.application_version()); + } + if (from.has_public_computer()) { + set_public_computer(from.public_computer()); + } + if (from.has_sso_id()) { + set_sso_id(from.sso_id()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from.has_disconnect_on_cookie_fail()) { + set_disconnect_on_cookie_fail(from.disconnect_on_cookie_fail()); + } + if (from.has_allow_logon_queue_notifications()) { + set_allow_logon_queue_notifications(from.allow_logon_queue_notifications()); + } + if (from.has_web_client_verification()) { + set_web_client_verification(from.web_client_verification()); + } + if (from.has_cached_web_credentials()) { + set_cached_web_credentials(from.cached_web_credentials()); + } + if (from.has_enable_cookie()) { + set_enable_cookie(from.enable_cookie()); + } + if (from.has_user_agent()) { + set_user_agent(from.user_agent()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void LogonRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void LogonRequest::CopyFrom(const LogonRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool LogonRequest::IsInitialized() const { + + return true; +} + +void LogonRequest::Swap(LogonRequest* other) { + if (other != this) { + std::swap(program_, other->program_); + std::swap(platform_, other->platform_); + std::swap(locale_, other->locale_); + std::swap(email_, other->email_); + std::swap(version_, other->version_); + std::swap(application_version_, other->application_version_); + std::swap(public_computer_, other->public_computer_); + std::swap(sso_id_, other->sso_id_); + std::swap(disconnect_on_cookie_fail_, other->disconnect_on_cookie_fail_); + std::swap(allow_logon_queue_notifications_, other->allow_logon_queue_notifications_); + std::swap(web_client_verification_, other->web_client_verification_); + std::swap(cached_web_credentials_, other->cached_web_credentials_); + std::swap(enable_cookie_, other->enable_cookie_); + std::swap(user_agent_, other->user_agent_); + 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 LogonRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = LogonRequest_descriptor_; + metadata.reflection = LogonRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int LogonResult::kErrorCodeFieldNumber; +const int LogonResult::kAccountIdFieldNumber; +const int LogonResult::kGameAccountIdFieldNumber; +const int LogonResult::kEmailFieldNumber; +const int LogonResult::kAvailableRegionFieldNumber; +const int LogonResult::kConnectedRegionFieldNumber; +const int LogonResult::kBattleTagFieldNumber; +const int LogonResult::kGeoipCountryFieldNumber; +const int LogonResult::kSessionKeyFieldNumber; +const int LogonResult::kRestrictedModeFieldNumber; +#endif // !_MSC_VER + +LogonResult::LogonResult() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.LogonResult) +} + +void LogonResult::InitAsDefaultInstance() { + account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +LogonResult::LogonResult(const LogonResult& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.LogonResult) +} + +void LogonResult::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + error_code_ = 0u; + account_id_ = NULL; + email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + connected_region_ = 0u; + battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + geoip_country_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + session_key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + restricted_mode_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +LogonResult::~LogonResult() { + // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.LogonResult) + SharedDtor(); +} + +void LogonResult::SharedDtor() { + if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete email_; + } + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete battle_tag_; + } + if (geoip_country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete geoip_country_; + } + if (session_key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete session_key_; + } + if (this != default_instance_) { + delete account_id_; + } +} + +void LogonResult::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* LogonResult::descriptor() { + protobuf_AssignDescriptorsOnce(); + return LogonResult_descriptor_; +} + +const LogonResult& LogonResult::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto(); + return *default_instance_; +} + +LogonResult* LogonResult::default_instance_ = NULL; + +LogonResult* LogonResult::New() const { + return new LogonResult; +} + +void LogonResult::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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] & 235) { + ZR_(error_code_, connected_region_); + if (has_account_id()) { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_email()) { + if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_->clear(); + } + } + if (has_battle_tag()) { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_->clear(); + } + } + if (has_geoip_country()) { + if (geoip_country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + geoip_country_->clear(); + } + } + } + if (_has_bits_[8 / 32] & 768) { + if (has_session_key()) { + if (session_key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + session_key_->clear(); + } + } + restricted_mode_ = false; + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + game_account_id_.Clear(); + available_region_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool LogonResult::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.LogonResult) + 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)) { + // required uint32 error_code = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &error_code_))); + set_has_error_code(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_account_id; + break; + } + + // optional .bgs.protocol.EntityId account_id = 2; + case 2: { + if (tag == 18) { + parse_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_game_account_id; + break; + } + + // repeated .bgs.protocol.EntityId game_account_id = 3; + case 3: { + if (tag == 26) { + parse_game_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_game_account_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_game_account_id; + if (input->ExpectTag(34)) goto parse_email; + break; + } + + // optional string email = 4; + case 4: { + if (tag == 34) { + parse_email: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_email())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->email().data(), this->email().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "email"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_available_region; + break; + } + + // repeated uint32 available_region = 5; + case 5: { + if (tag == 40) { + parse_available_region: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 40, input, this->mutable_available_region()))); + } else if (tag == 42) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_available_region()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_available_region; + if (input->ExpectTag(48)) goto parse_connected_region; + break; + } + + // optional uint32 connected_region = 6; + case 6: { + if (tag == 48) { + parse_connected_region: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &connected_region_))); + set_has_connected_region(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(58)) goto parse_battle_tag; + break; + } + + // optional string battle_tag = 7; + case 7: { + if (tag == 58) { + parse_battle_tag: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_battle_tag())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->battle_tag().data(), this->battle_tag().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "battle_tag"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(66)) goto parse_geoip_country; + break; + } + + // optional string geoip_country = 8; + case 8: { + if (tag == 66) { + parse_geoip_country: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_geoip_country())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->geoip_country().data(), this->geoip_country().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "geoip_country"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(74)) goto parse_session_key; + break; + } + + // optional bytes session_key = 9; + case 9: { + if (tag == 74) { + parse_session_key: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_session_key())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(80)) goto parse_restricted_mode; + break; + } + + // optional bool restricted_mode = 10; + case 10: { + if (tag == 80) { + parse_restricted_mode: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &restricted_mode_))); + set_has_restricted_mode(); + } 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:bgs.protocol.authentication.v1.LogonResult) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.LogonResult) + return false; +#undef DO_ +} + +void LogonResult::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.LogonResult) + // required uint32 error_code = 1; + if (has_error_code()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->error_code(), output); + } + + // optional .bgs.protocol.EntityId account_id = 2; + if (has_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->account_id(), output); + } + + // repeated .bgs.protocol.EntityId game_account_id = 3; + for (int i = 0; i < this->game_account_id_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->game_account_id(i), output); + } + + // optional string email = 4; + if (has_email()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->email().data(), this->email().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "email"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 4, this->email(), output); + } + + // repeated uint32 available_region = 5; + for (int i = 0; i < this->available_region_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32( + 5, this->available_region(i), output); + } + + // optional uint32 connected_region = 6; + if (has_connected_region()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->connected_region(), output); + } + + // optional string battle_tag = 7; + if (has_battle_tag()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->battle_tag().data(), this->battle_tag().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "battle_tag"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 7, this->battle_tag(), output); + } + + // optional string geoip_country = 8; + if (has_geoip_country()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->geoip_country().data(), this->geoip_country().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "geoip_country"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 8, this->geoip_country(), output); + } + + // optional bytes session_key = 9; + if (has_session_key()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 9, this->session_key(), output); + } + + // optional bool restricted_mode = 10; + if (has_restricted_mode()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(10, this->restricted_mode(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.LogonResult) +} + +::google::protobuf::uint8* LogonResult::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.LogonResult) + // required uint32 error_code = 1; + if (has_error_code()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->error_code(), target); + } + + // optional .bgs.protocol.EntityId account_id = 2; + if (has_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->account_id(), target); + } + + // repeated .bgs.protocol.EntityId game_account_id = 3; + for (int i = 0; i < this->game_account_id_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->game_account_id(i), target); + } + + // optional string email = 4; + if (has_email()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->email().data(), this->email().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "email"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->email(), target); + } + + // repeated uint32 available_region = 5; + for (int i = 0; i < this->available_region_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32ToArray(5, this->available_region(i), target); + } + + // optional uint32 connected_region = 6; + if (has_connected_region()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->connected_region(), target); + } + + // optional string battle_tag = 7; + if (has_battle_tag()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->battle_tag().data(), this->battle_tag().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "battle_tag"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 7, this->battle_tag(), target); + } + + // optional string geoip_country = 8; + if (has_geoip_country()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->geoip_country().data(), this->geoip_country().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "geoip_country"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 8, this->geoip_country(), target); + } + + // optional bytes session_key = 9; + if (has_session_key()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 9, this->session_key(), target); + } + + // optional bool restricted_mode = 10; + if (has_restricted_mode()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(10, this->restricted_mode(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.LogonResult) + return target; +} + +int LogonResult::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required uint32 error_code = 1; + if (has_error_code()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->error_code()); + } + + // optional .bgs.protocol.EntityId account_id = 2; + if (has_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account_id()); + } + + // optional string email = 4; + if (has_email()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->email()); + } + + // optional uint32 connected_region = 6; + if (has_connected_region()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->connected_region()); + } + + // optional string battle_tag = 7; + if (has_battle_tag()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->battle_tag()); + } + + // optional string geoip_country = 8; + if (has_geoip_country()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->geoip_country()); + } + + } + if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + // optional bytes session_key = 9; + if (has_session_key()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->session_key()); + } + + // optional bool restricted_mode = 10; + if (has_restricted_mode()) { + total_size += 1 + 1; + } + + } + // repeated .bgs.protocol.EntityId game_account_id = 3; + total_size += 1 * this->game_account_id_size(); + for (int i = 0; i < this->game_account_id_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account_id(i)); + } + + // repeated uint32 available_region = 5; + { + int data_size = 0; + for (int i = 0; i < this->available_region_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->available_region(i)); + } + total_size += 1 * this->available_region_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 LogonResult::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const LogonResult* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void LogonResult::MergeFrom(const LogonResult& from) { + GOOGLE_CHECK_NE(&from, this); + game_account_id_.MergeFrom(from.game_account_id_); + available_region_.MergeFrom(from.available_region_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_error_code()) { + set_error_code(from.error_code()); + } + if (from.has_account_id()) { + mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id()); + } + if (from.has_email()) { + set_email(from.email()); + } + if (from.has_connected_region()) { + set_connected_region(from.connected_region()); + } + if (from.has_battle_tag()) { + set_battle_tag(from.battle_tag()); + } + if (from.has_geoip_country()) { + set_geoip_country(from.geoip_country()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from.has_session_key()) { + set_session_key(from.session_key()); + } + if (from.has_restricted_mode()) { + set_restricted_mode(from.restricted_mode()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void LogonResult::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void LogonResult::CopyFrom(const LogonResult& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool LogonResult::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_account_id()) { + if (!this->account_id().IsInitialized()) return false; + } + if (!::google::protobuf::internal::AllAreInitialized(this->game_account_id())) return false; + return true; +} + +void LogonResult::Swap(LogonResult* other) { + if (other != this) { + std::swap(error_code_, other->error_code_); + std::swap(account_id_, other->account_id_); + game_account_id_.Swap(&other->game_account_id_); + std::swap(email_, other->email_); + available_region_.Swap(&other->available_region_); + std::swap(connected_region_, other->connected_region_); + std::swap(battle_tag_, other->battle_tag_); + std::swap(geoip_country_, other->geoip_country_); + std::swap(session_key_, other->session_key_); + std::swap(restricted_mode_, other->restricted_mode_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata LogonResult::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = LogonResult_descriptor_; + metadata.reflection = LogonResult_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GenerateSSOTokenRequest::kProgramFieldNumber; +#endif // !_MSC_VER + +GenerateSSOTokenRequest::GenerateSSOTokenRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.GenerateSSOTokenRequest) +} + +void GenerateSSOTokenRequest::InitAsDefaultInstance() { +} + +GenerateSSOTokenRequest::GenerateSSOTokenRequest(const GenerateSSOTokenRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.GenerateSSOTokenRequest) +} + +void GenerateSSOTokenRequest::SharedCtor() { + _cached_size_ = 0; + program_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GenerateSSOTokenRequest::~GenerateSSOTokenRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.GenerateSSOTokenRequest) + SharedDtor(); +} + +void GenerateSSOTokenRequest::SharedDtor() { + if (this != default_instance_) { + } +} + +void GenerateSSOTokenRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GenerateSSOTokenRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GenerateSSOTokenRequest_descriptor_; +} + +const GenerateSSOTokenRequest& GenerateSSOTokenRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto(); + return *default_instance_; +} + +GenerateSSOTokenRequest* GenerateSSOTokenRequest::default_instance_ = NULL; + +GenerateSSOTokenRequest* GenerateSSOTokenRequest::New() const { + return new GenerateSSOTokenRequest; +} + +void GenerateSSOTokenRequest::Clear() { + program_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GenerateSSOTokenRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.GenerateSSOTokenRequest) + 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 program = 1; + case 1: { + if (tag == 13) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &program_))); + set_has_program(); + } 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:bgs.protocol.authentication.v1.GenerateSSOTokenRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.GenerateSSOTokenRequest) + return false; +#undef DO_ +} + +void GenerateSSOTokenRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.GenerateSSOTokenRequest) + // optional fixed32 program = 1; + if (has_program()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->program(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.GenerateSSOTokenRequest) +} + +::google::protobuf::uint8* GenerateSSOTokenRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.GenerateSSOTokenRequest) + // optional fixed32 program = 1; + if (has_program()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->program(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.GenerateSSOTokenRequest) + return target; +} + +int GenerateSSOTokenRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional fixed32 program = 1; + if (has_program()) { + 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 GenerateSSOTokenRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GenerateSSOTokenRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GenerateSSOTokenRequest::MergeFrom(const GenerateSSOTokenRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_program()) { + set_program(from.program()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GenerateSSOTokenRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GenerateSSOTokenRequest::CopyFrom(const GenerateSSOTokenRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GenerateSSOTokenRequest::IsInitialized() const { + + return true; +} + +void GenerateSSOTokenRequest::Swap(GenerateSSOTokenRequest* other) { + if (other != this) { + std::swap(program_, other->program_); + 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 GenerateSSOTokenRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GenerateSSOTokenRequest_descriptor_; + metadata.reflection = GenerateSSOTokenRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GenerateSSOTokenResponse::kSsoIdFieldNumber; +const int GenerateSSOTokenResponse::kSsoSecretFieldNumber; +#endif // !_MSC_VER + +GenerateSSOTokenResponse::GenerateSSOTokenResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.GenerateSSOTokenResponse) +} + +void GenerateSSOTokenResponse::InitAsDefaultInstance() { +} + +GenerateSSOTokenResponse::GenerateSSOTokenResponse(const GenerateSSOTokenResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.GenerateSSOTokenResponse) +} + +void GenerateSSOTokenResponse::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + sso_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + sso_secret_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GenerateSSOTokenResponse::~GenerateSSOTokenResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.GenerateSSOTokenResponse) + SharedDtor(); +} + +void GenerateSSOTokenResponse::SharedDtor() { + if (sso_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete sso_id_; + } + if (sso_secret_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete sso_secret_; + } + if (this != default_instance_) { + } +} + +void GenerateSSOTokenResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GenerateSSOTokenResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GenerateSSOTokenResponse_descriptor_; +} + +const GenerateSSOTokenResponse& GenerateSSOTokenResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto(); + return *default_instance_; +} + +GenerateSSOTokenResponse* GenerateSSOTokenResponse::default_instance_ = NULL; + +GenerateSSOTokenResponse* GenerateSSOTokenResponse::New() const { + return new GenerateSSOTokenResponse; +} + +void GenerateSSOTokenResponse::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_sso_id()) { + if (sso_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sso_id_->clear(); + } + } + if (has_sso_secret()) { + if (sso_secret_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sso_secret_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GenerateSSOTokenResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.GenerateSSOTokenResponse) + 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 sso_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_sso_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_sso_secret; + break; + } + + // optional bytes sso_secret = 2; + case 2: { + if (tag == 18) { + parse_sso_secret: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_sso_secret())); + } 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:bgs.protocol.authentication.v1.GenerateSSOTokenResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.GenerateSSOTokenResponse) + return false; +#undef DO_ +} + +void GenerateSSOTokenResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.GenerateSSOTokenResponse) + // optional bytes sso_id = 1; + if (has_sso_id()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 1, this->sso_id(), output); + } + + // optional bytes sso_secret = 2; + if (has_sso_secret()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 2, this->sso_secret(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.GenerateSSOTokenResponse) +} + +::google::protobuf::uint8* GenerateSSOTokenResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.GenerateSSOTokenResponse) + // optional bytes sso_id = 1; + if (has_sso_id()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 1, this->sso_id(), target); + } + + // optional bytes sso_secret = 2; + if (has_sso_secret()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 2, this->sso_secret(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.GenerateSSOTokenResponse) + return target; +} + +int GenerateSSOTokenResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional bytes sso_id = 1; + if (has_sso_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->sso_id()); + } + + // optional bytes sso_secret = 2; + if (has_sso_secret()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->sso_secret()); + } + + } + 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 GenerateSSOTokenResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GenerateSSOTokenResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GenerateSSOTokenResponse::MergeFrom(const GenerateSSOTokenResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_sso_id()) { + set_sso_id(from.sso_id()); + } + if (from.has_sso_secret()) { + set_sso_secret(from.sso_secret()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GenerateSSOTokenResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GenerateSSOTokenResponse::CopyFrom(const GenerateSSOTokenResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GenerateSSOTokenResponse::IsInitialized() const { + + return true; +} + +void GenerateSSOTokenResponse::Swap(GenerateSSOTokenResponse* other) { + if (other != this) { + std::swap(sso_id_, other->sso_id_); + std::swap(sso_secret_, other->sso_secret_); + 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 GenerateSSOTokenResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GenerateSSOTokenResponse_descriptor_; + metadata.reflection = GenerateSSOTokenResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int LogonUpdateRequest::kErrorCodeFieldNumber; +#endif // !_MSC_VER + +LogonUpdateRequest::LogonUpdateRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.LogonUpdateRequest) +} + +void LogonUpdateRequest::InitAsDefaultInstance() { +} + +LogonUpdateRequest::LogonUpdateRequest(const LogonUpdateRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.LogonUpdateRequest) +} + +void LogonUpdateRequest::SharedCtor() { + _cached_size_ = 0; + error_code_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +LogonUpdateRequest::~LogonUpdateRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.LogonUpdateRequest) + SharedDtor(); +} + +void LogonUpdateRequest::SharedDtor() { + if (this != default_instance_) { + } +} + +void LogonUpdateRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* LogonUpdateRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return LogonUpdateRequest_descriptor_; +} + +const LogonUpdateRequest& LogonUpdateRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto(); + return *default_instance_; +} + +LogonUpdateRequest* LogonUpdateRequest::default_instance_ = NULL; + +LogonUpdateRequest* LogonUpdateRequest::New() const { + return new LogonUpdateRequest; +} + +void LogonUpdateRequest::Clear() { + error_code_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool LogonUpdateRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.LogonUpdateRequest) + 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)) { + // required uint32 error_code = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &error_code_))); + set_has_error_code(); + } 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:bgs.protocol.authentication.v1.LogonUpdateRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.LogonUpdateRequest) + return false; +#undef DO_ +} + +void LogonUpdateRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.LogonUpdateRequest) + // required uint32 error_code = 1; + if (has_error_code()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->error_code(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.LogonUpdateRequest) +} + +::google::protobuf::uint8* LogonUpdateRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.LogonUpdateRequest) + // required uint32 error_code = 1; + if (has_error_code()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->error_code(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.LogonUpdateRequest) + return target; +} + +int LogonUpdateRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required uint32 error_code = 1; + if (has_error_code()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->error_code()); + } + + } + 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 LogonUpdateRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const LogonUpdateRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void LogonUpdateRequest::MergeFrom(const LogonUpdateRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_error_code()) { + set_error_code(from.error_code()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void LogonUpdateRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void LogonUpdateRequest::CopyFrom(const LogonUpdateRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool LogonUpdateRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void LogonUpdateRequest::Swap(LogonUpdateRequest* other) { + if (other != this) { + std::swap(error_code_, other->error_code_); + 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 LogonUpdateRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = LogonUpdateRequest_descriptor_; + metadata.reflection = LogonUpdateRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int LogonQueueUpdateRequest::kPositionFieldNumber; +const int LogonQueueUpdateRequest::kEstimatedTimeFieldNumber; +const int LogonQueueUpdateRequest::kEtaDeviationInSecFieldNumber; +#endif // !_MSC_VER + +LogonQueueUpdateRequest::LogonQueueUpdateRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.LogonQueueUpdateRequest) +} + +void LogonQueueUpdateRequest::InitAsDefaultInstance() { +} + +LogonQueueUpdateRequest::LogonQueueUpdateRequest(const LogonQueueUpdateRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.LogonQueueUpdateRequest) +} + +void LogonQueueUpdateRequest::SharedCtor() { + _cached_size_ = 0; + position_ = 0u; + estimated_time_ = GOOGLE_ULONGLONG(0); + eta_deviation_in_sec_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +LogonQueueUpdateRequest::~LogonQueueUpdateRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.LogonQueueUpdateRequest) + SharedDtor(); +} + +void LogonQueueUpdateRequest::SharedDtor() { + if (this != default_instance_) { + } +} + +void LogonQueueUpdateRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* LogonQueueUpdateRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return LogonQueueUpdateRequest_descriptor_; +} + +const LogonQueueUpdateRequest& LogonQueueUpdateRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto(); + return *default_instance_; +} + +LogonQueueUpdateRequest* LogonQueueUpdateRequest::default_instance_ = NULL; + +LogonQueueUpdateRequest* LogonQueueUpdateRequest::New() const { + return new LogonQueueUpdateRequest; +} + +void LogonQueueUpdateRequest::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(estimated_time_, position_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool LogonQueueUpdateRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.LogonQueueUpdateRequest) + 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)) { + // required uint32 position = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &position_))); + set_has_position(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_estimated_time; + break; + } + + // required uint64 estimated_time = 2; + case 2: { + if (tag == 16) { + parse_estimated_time: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &estimated_time_))); + set_has_estimated_time(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_eta_deviation_in_sec; + break; + } + + // required uint64 eta_deviation_in_sec = 3; + case 3: { + if (tag == 24) { + parse_eta_deviation_in_sec: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &eta_deviation_in_sec_))); + set_has_eta_deviation_in_sec(); + } 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:bgs.protocol.authentication.v1.LogonQueueUpdateRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.LogonQueueUpdateRequest) + return false; +#undef DO_ +} + +void LogonQueueUpdateRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.LogonQueueUpdateRequest) + // required uint32 position = 1; + if (has_position()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->position(), output); + } + + // required uint64 estimated_time = 2; + if (has_estimated_time()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->estimated_time(), output); + } + + // required uint64 eta_deviation_in_sec = 3; + if (has_eta_deviation_in_sec()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->eta_deviation_in_sec(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.LogonQueueUpdateRequest) +} + +::google::protobuf::uint8* LogonQueueUpdateRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.LogonQueueUpdateRequest) + // required uint32 position = 1; + if (has_position()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->position(), target); + } + + // required uint64 estimated_time = 2; + if (has_estimated_time()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->estimated_time(), target); + } + + // required uint64 eta_deviation_in_sec = 3; + if (has_eta_deviation_in_sec()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->eta_deviation_in_sec(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.LogonQueueUpdateRequest) + return target; +} + +int LogonQueueUpdateRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required uint32 position = 1; + if (has_position()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->position()); + } + + // required uint64 estimated_time = 2; + if (has_estimated_time()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->estimated_time()); + } + + // required uint64 eta_deviation_in_sec = 3; + if (has_eta_deviation_in_sec()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->eta_deviation_in_sec()); + } + + } + 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 LogonQueueUpdateRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const LogonQueueUpdateRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void LogonQueueUpdateRequest::MergeFrom(const LogonQueueUpdateRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_position()) { + set_position(from.position()); + } + if (from.has_estimated_time()) { + set_estimated_time(from.estimated_time()); + } + if (from.has_eta_deviation_in_sec()) { + set_eta_deviation_in_sec(from.eta_deviation_in_sec()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void LogonQueueUpdateRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void LogonQueueUpdateRequest::CopyFrom(const LogonQueueUpdateRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool LogonQueueUpdateRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + return true; +} + +void LogonQueueUpdateRequest::Swap(LogonQueueUpdateRequest* other) { + if (other != this) { + std::swap(position_, other->position_); + std::swap(estimated_time_, other->estimated_time_); + std::swap(eta_deviation_in_sec_, other->eta_deviation_in_sec_); + 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 LogonQueueUpdateRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = LogonQueueUpdateRequest_descriptor_; + metadata.reflection = LogonQueueUpdateRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AccountSettingsNotification::kLicensesFieldNumber; +const int AccountSettingsNotification::kIsUsingRidFieldNumber; +const int AccountSettingsNotification::kIsPlayingFromIgrFieldNumber; +const int AccountSettingsNotification::kCanReceiveVoiceFieldNumber; +const int AccountSettingsNotification::kCanSendVoiceFieldNumber; +#endif // !_MSC_VER + +AccountSettingsNotification::AccountSettingsNotification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.AccountSettingsNotification) +} + +void AccountSettingsNotification::InitAsDefaultInstance() { +} + +AccountSettingsNotification::AccountSettingsNotification(const AccountSettingsNotification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.AccountSettingsNotification) +} + +void AccountSettingsNotification::SharedCtor() { + _cached_size_ = 0; + is_using_rid_ = false; + is_playing_from_igr_ = false; + can_receive_voice_ = false; + can_send_voice_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AccountSettingsNotification::~AccountSettingsNotification() { + // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.AccountSettingsNotification) + SharedDtor(); +} + +void AccountSettingsNotification::SharedDtor() { + if (this != default_instance_) { + } +} + +void AccountSettingsNotification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AccountSettingsNotification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AccountSettingsNotification_descriptor_; +} + +const AccountSettingsNotification& AccountSettingsNotification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto(); + return *default_instance_; +} + +AccountSettingsNotification* AccountSettingsNotification::default_instance_ = NULL; + +AccountSettingsNotification* AccountSettingsNotification::New() const { + return new AccountSettingsNotification; +} + +void AccountSettingsNotification::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(is_using_rid_, can_send_voice_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + licenses_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AccountSettingsNotification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.AccountSettingsNotification) + 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 .bgs.protocol.account.v1.AccountLicense licenses = 1; + case 1: { + if (tag == 10) { + parse_licenses: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_licenses())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_licenses; + if (input->ExpectTag(16)) goto parse_is_using_rid; + break; + } + + // optional bool is_using_rid = 2; + case 2: { + if (tag == 16) { + parse_is_using_rid: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_using_rid_))); + set_has_is_using_rid(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_is_playing_from_igr; + break; + } + + // optional bool is_playing_from_igr = 3; + case 3: { + if (tag == 24) { + parse_is_playing_from_igr: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_playing_from_igr_))); + set_has_is_playing_from_igr(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_can_receive_voice; + break; + } + + // optional bool can_receive_voice = 4; + case 4: { + if (tag == 32) { + parse_can_receive_voice: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &can_receive_voice_))); + set_has_can_receive_voice(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_can_send_voice; + break; + } + + // optional bool can_send_voice = 5; + case 5: { + if (tag == 40) { + parse_can_send_voice: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &can_send_voice_))); + set_has_can_send_voice(); + } 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:bgs.protocol.authentication.v1.AccountSettingsNotification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.AccountSettingsNotification) + return false; +#undef DO_ +} + +void AccountSettingsNotification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.AccountSettingsNotification) + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 1; + for (int i = 0; i < this->licenses_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->licenses(i), output); + } + + // optional bool is_using_rid = 2; + if (has_is_using_rid()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->is_using_rid(), output); + } + + // optional bool is_playing_from_igr = 3; + if (has_is_playing_from_igr()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->is_playing_from_igr(), output); + } + + // optional bool can_receive_voice = 4; + if (has_can_receive_voice()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->can_receive_voice(), output); + } + + // optional bool can_send_voice = 5; + if (has_can_send_voice()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->can_send_voice(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.AccountSettingsNotification) +} + +::google::protobuf::uint8* AccountSettingsNotification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.AccountSettingsNotification) + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 1; + for (int i = 0; i < this->licenses_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->licenses(i), target); + } + + // optional bool is_using_rid = 2; + if (has_is_using_rid()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->is_using_rid(), target); + } + + // optional bool is_playing_from_igr = 3; + if (has_is_playing_from_igr()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->is_playing_from_igr(), target); + } + + // optional bool can_receive_voice = 4; + if (has_can_receive_voice()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->can_receive_voice(), target); + } + + // optional bool can_send_voice = 5; + if (has_can_send_voice()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->can_send_voice(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.AccountSettingsNotification) + return target; +} + +int AccountSettingsNotification::ByteSize() const { + int total_size = 0; + + if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) { + // optional bool is_using_rid = 2; + if (has_is_using_rid()) { + total_size += 1 + 1; + } + + // optional bool is_playing_from_igr = 3; + if (has_is_playing_from_igr()) { + total_size += 1 + 1; + } + + // optional bool can_receive_voice = 4; + if (has_can_receive_voice()) { + total_size += 1 + 1; + } + + // optional bool can_send_voice = 5; + if (has_can_send_voice()) { + total_size += 1 + 1; + } + + } + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 1; + total_size += 1 * this->licenses_size(); + for (int i = 0; i < this->licenses_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->licenses(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 AccountSettingsNotification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AccountSettingsNotification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AccountSettingsNotification::MergeFrom(const AccountSettingsNotification& from) { + GOOGLE_CHECK_NE(&from, this); + licenses_.MergeFrom(from.licenses_); + if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) { + if (from.has_is_using_rid()) { + set_is_using_rid(from.is_using_rid()); + } + if (from.has_is_playing_from_igr()) { + set_is_playing_from_igr(from.is_playing_from_igr()); + } + if (from.has_can_receive_voice()) { + set_can_receive_voice(from.can_receive_voice()); + } + if (from.has_can_send_voice()) { + set_can_send_voice(from.can_send_voice()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AccountSettingsNotification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AccountSettingsNotification::CopyFrom(const AccountSettingsNotification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AccountSettingsNotification::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->licenses())) return false; + return true; +} + +void AccountSettingsNotification::Swap(AccountSettingsNotification* other) { + if (other != this) { + licenses_.Swap(&other->licenses_); + std::swap(is_using_rid_, other->is_using_rid_); + std::swap(is_playing_from_igr_, other->is_playing_from_igr_); + std::swap(can_receive_voice_, other->can_receive_voice_); + std::swap(can_send_voice_, other->can_send_voice_); + 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 AccountSettingsNotification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AccountSettingsNotification_descriptor_; + metadata.reflection = AccountSettingsNotification_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ServerStateChangeRequest::kStateFieldNumber; +const int ServerStateChangeRequest::kEventTimeFieldNumber; +#endif // !_MSC_VER + +ServerStateChangeRequest::ServerStateChangeRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.ServerStateChangeRequest) +} + +void ServerStateChangeRequest::InitAsDefaultInstance() { +} + +ServerStateChangeRequest::ServerStateChangeRequest(const ServerStateChangeRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.ServerStateChangeRequest) +} + +void ServerStateChangeRequest::SharedCtor() { + _cached_size_ = 0; + state_ = 0u; + event_time_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ServerStateChangeRequest::~ServerStateChangeRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.ServerStateChangeRequest) + SharedDtor(); +} + +void ServerStateChangeRequest::SharedDtor() { + if (this != default_instance_) { + } +} + +void ServerStateChangeRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ServerStateChangeRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ServerStateChangeRequest_descriptor_; +} + +const ServerStateChangeRequest& ServerStateChangeRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto(); + return *default_instance_; +} + +ServerStateChangeRequest* ServerStateChangeRequest::default_instance_ = NULL; + +ServerStateChangeRequest* ServerStateChangeRequest::New() const { + return new ServerStateChangeRequest; +} + +void ServerStateChangeRequest::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(event_time_, state_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ServerStateChangeRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.ServerStateChangeRequest) + 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)) { + // required uint32 state = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &state_))); + set_has_state(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_event_time; + break; + } + + // required uint64 event_time = 2; + case 2: { + if (tag == 16) { + parse_event_time: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &event_time_))); + set_has_event_time(); + } 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:bgs.protocol.authentication.v1.ServerStateChangeRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.ServerStateChangeRequest) + return false; +#undef DO_ +} + +void ServerStateChangeRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.ServerStateChangeRequest) + // required uint32 state = 1; + if (has_state()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->state(), output); + } + + // required uint64 event_time = 2; + if (has_event_time()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->event_time(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.ServerStateChangeRequest) +} + +::google::protobuf::uint8* ServerStateChangeRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.ServerStateChangeRequest) + // required uint32 state = 1; + if (has_state()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->state(), target); + } + + // required uint64 event_time = 2; + if (has_event_time()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->event_time(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.ServerStateChangeRequest) + return target; +} + +int ServerStateChangeRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required uint32 state = 1; + if (has_state()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->state()); + } + + // required uint64 event_time = 2; + if (has_event_time()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->event_time()); + } + + } + 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 ServerStateChangeRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ServerStateChangeRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ServerStateChangeRequest::MergeFrom(const ServerStateChangeRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_state()) { + set_state(from.state()); + } + if (from.has_event_time()) { + set_event_time(from.event_time()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ServerStateChangeRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ServerStateChangeRequest::CopyFrom(const ServerStateChangeRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ServerStateChangeRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void ServerStateChangeRequest::Swap(ServerStateChangeRequest* other) { + if (other != this) { + std::swap(state_, other->state_); + std::swap(event_time_, other->event_time_); + 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 ServerStateChangeRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ServerStateChangeRequest_descriptor_; + metadata.reflection = ServerStateChangeRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int VersionInfo::kNumberFieldNumber; +const int VersionInfo::kPatchFieldNumber; +const int VersionInfo::kIsOptionalFieldNumber; +const int VersionInfo::kKickTimeFieldNumber; +#endif // !_MSC_VER + +VersionInfo::VersionInfo() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.VersionInfo) +} + +void VersionInfo::InitAsDefaultInstance() { +} + +VersionInfo::VersionInfo(const VersionInfo& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.VersionInfo) +} + +void VersionInfo::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + number_ = 0u; + patch_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + is_optional_ = false; + kick_time_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +VersionInfo::~VersionInfo() { + // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.VersionInfo) + SharedDtor(); +} + +void VersionInfo::SharedDtor() { + if (patch_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete patch_; + } + if (this != default_instance_) { + } +} + +void VersionInfo::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* VersionInfo::descriptor() { + protobuf_AssignDescriptorsOnce(); + return VersionInfo_descriptor_; +} + +const VersionInfo& VersionInfo::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto(); + return *default_instance_; +} + +VersionInfo* VersionInfo::default_instance_ = NULL; + +VersionInfo* VersionInfo::New() const { + return new VersionInfo; +} + +void VersionInfo::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(number_, kick_time_); + if (has_patch()) { + if (patch_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + patch_->clear(); + } + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool VersionInfo::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.VersionInfo) + 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 number = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &number_))); + set_has_number(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_patch; + break; + } + + // optional string patch = 2; + case 2: { + if (tag == 18) { + parse_patch: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_patch())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->patch().data(), this->patch().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "patch"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_is_optional; + break; + } + + // optional bool is_optional = 3; + case 3: { + if (tag == 24) { + parse_is_optional: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_optional_))); + set_has_is_optional(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_kick_time; + break; + } + + // optional uint64 kick_time = 4; + case 4: { + if (tag == 32) { + parse_kick_time: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &kick_time_))); + set_has_kick_time(); + } 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:bgs.protocol.authentication.v1.VersionInfo) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.VersionInfo) + return false; +#undef DO_ +} + +void VersionInfo::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.VersionInfo) + // optional uint32 number = 1; + if (has_number()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->number(), output); + } + + // optional string patch = 2; + if (has_patch()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->patch().data(), this->patch().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "patch"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->patch(), output); + } + + // optional bool is_optional = 3; + if (has_is_optional()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->is_optional(), output); + } + + // optional uint64 kick_time = 4; + if (has_kick_time()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->kick_time(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.VersionInfo) +} + +::google::protobuf::uint8* VersionInfo::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.VersionInfo) + // optional uint32 number = 1; + if (has_number()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->number(), target); + } + + // optional string patch = 2; + if (has_patch()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->patch().data(), this->patch().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "patch"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->patch(), target); + } + + // optional bool is_optional = 3; + if (has_is_optional()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->is_optional(), target); + } + + // optional uint64 kick_time = 4; + if (has_kick_time()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->kick_time(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.VersionInfo) + return target; +} + +int VersionInfo::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional uint32 number = 1; + if (has_number()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->number()); + } + + // optional string patch = 2; + if (has_patch()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->patch()); + } + + // optional bool is_optional = 3; + if (has_is_optional()) { + total_size += 1 + 1; + } + + // optional uint64 kick_time = 4; + if (has_kick_time()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->kick_time()); + } + + } + 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 VersionInfo::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const VersionInfo* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void VersionInfo::MergeFrom(const VersionInfo& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_number()) { + set_number(from.number()); + } + if (from.has_patch()) { + set_patch(from.patch()); + } + if (from.has_is_optional()) { + set_is_optional(from.is_optional()); + } + if (from.has_kick_time()) { + set_kick_time(from.kick_time()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void VersionInfo::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void VersionInfo::CopyFrom(const VersionInfo& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VersionInfo::IsInitialized() const { + + return true; +} + +void VersionInfo::Swap(VersionInfo* other) { + if (other != this) { + std::swap(number_, other->number_); + std::swap(patch_, other->patch_); + std::swap(is_optional_, other->is_optional_); + std::swap(kick_time_, other->kick_time_); + 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 VersionInfo::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = VersionInfo_descriptor_; + metadata.reflection = VersionInfo_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int VersionInfoNotification::kVersionInfoFieldNumber; +#endif // !_MSC_VER + +VersionInfoNotification::VersionInfoNotification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.VersionInfoNotification) +} + +void VersionInfoNotification::InitAsDefaultInstance() { + version_info_ = const_cast< ::bgs::protocol::authentication::v1::VersionInfo*>(&::bgs::protocol::authentication::v1::VersionInfo::default_instance()); +} + +VersionInfoNotification::VersionInfoNotification(const VersionInfoNotification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.VersionInfoNotification) +} + +void VersionInfoNotification::SharedCtor() { + _cached_size_ = 0; + version_info_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +VersionInfoNotification::~VersionInfoNotification() { + // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.VersionInfoNotification) + SharedDtor(); +} + +void VersionInfoNotification::SharedDtor() { + if (this != default_instance_) { + delete version_info_; + } +} + +void VersionInfoNotification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* VersionInfoNotification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return VersionInfoNotification_descriptor_; +} + +const VersionInfoNotification& VersionInfoNotification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto(); + return *default_instance_; +} + +VersionInfoNotification* VersionInfoNotification::default_instance_ = NULL; + +VersionInfoNotification* VersionInfoNotification::New() const { + return new VersionInfoNotification; +} + +void VersionInfoNotification::Clear() { + if (has_version_info()) { + if (version_info_ != NULL) version_info_->::bgs::protocol::authentication::v1::VersionInfo::Clear(); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool VersionInfoNotification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.VersionInfoNotification) + 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 .bgs.protocol.authentication.v1.VersionInfo version_info = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_version_info())); + } 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:bgs.protocol.authentication.v1.VersionInfoNotification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.VersionInfoNotification) + return false; +#undef DO_ +} + +void VersionInfoNotification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.VersionInfoNotification) + // optional .bgs.protocol.authentication.v1.VersionInfo version_info = 1; + if (has_version_info()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->version_info(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.VersionInfoNotification) +} + +::google::protobuf::uint8* VersionInfoNotification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.VersionInfoNotification) + // optional .bgs.protocol.authentication.v1.VersionInfo version_info = 1; + if (has_version_info()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->version_info(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.VersionInfoNotification) + return target; +} + +int VersionInfoNotification::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.authentication.v1.VersionInfo version_info = 1; + if (has_version_info()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->version_info()); + } + + } + 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 VersionInfoNotification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const VersionInfoNotification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void VersionInfoNotification::MergeFrom(const VersionInfoNotification& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_version_info()) { + mutable_version_info()->::bgs::protocol::authentication::v1::VersionInfo::MergeFrom(from.version_info()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void VersionInfoNotification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void VersionInfoNotification::CopyFrom(const VersionInfoNotification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VersionInfoNotification::IsInitialized() const { + + return true; +} + +void VersionInfoNotification::Swap(VersionInfoNotification* other) { + if (other != this) { + std::swap(version_info_, other->version_info_); + 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 VersionInfoNotification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = VersionInfoNotification_descriptor_; + metadata.reflection = VersionInfoNotification_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int MemModuleLoadRequest::kHandleFieldNumber; +const int MemModuleLoadRequest::kKeyFieldNumber; +const int MemModuleLoadRequest::kInputFieldNumber; +#endif // !_MSC_VER + +MemModuleLoadRequest::MemModuleLoadRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.MemModuleLoadRequest) +} + +void MemModuleLoadRequest::InitAsDefaultInstance() { + handle_ = const_cast< ::bgs::protocol::ContentHandle*>(&::bgs::protocol::ContentHandle::default_instance()); +} + +MemModuleLoadRequest::MemModuleLoadRequest(const MemModuleLoadRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.MemModuleLoadRequest) +} + +void MemModuleLoadRequest::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + handle_ = NULL; + key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + input_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +MemModuleLoadRequest::~MemModuleLoadRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.MemModuleLoadRequest) + SharedDtor(); +} + +void MemModuleLoadRequest::SharedDtor() { + if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete key_; + } + if (input_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete input_; + } + if (this != default_instance_) { + delete handle_; + } +} + +void MemModuleLoadRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* MemModuleLoadRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return MemModuleLoadRequest_descriptor_; +} + +const MemModuleLoadRequest& MemModuleLoadRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto(); + return *default_instance_; +} + +MemModuleLoadRequest* MemModuleLoadRequest::default_instance_ = NULL; + +MemModuleLoadRequest* MemModuleLoadRequest::New() const { + return new MemModuleLoadRequest; +} + +void MemModuleLoadRequest::Clear() { + if (_has_bits_[0 / 32] & 7) { + if (has_handle()) { + if (handle_ != NULL) handle_->::bgs::protocol::ContentHandle::Clear(); + } + if (has_key()) { + if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + key_->clear(); + } + } + if (has_input()) { + if (input_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + input_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool MemModuleLoadRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.MemModuleLoadRequest) + 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)) { + // required .bgs.protocol.ContentHandle handle = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_handle())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_key; + break; + } + + // required bytes key = 2; + case 2: { + if (tag == 18) { + parse_key: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_key())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_input; + break; + } + + // required bytes input = 3; + case 3: { + if (tag == 26) { + parse_input: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_input())); + } 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:bgs.protocol.authentication.v1.MemModuleLoadRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.MemModuleLoadRequest) + return false; +#undef DO_ +} + +void MemModuleLoadRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.MemModuleLoadRequest) + // required .bgs.protocol.ContentHandle handle = 1; + if (has_handle()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->handle(), output); + } + + // required bytes key = 2; + if (has_key()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 2, this->key(), output); + } + + // required bytes input = 3; + if (has_input()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 3, this->input(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.MemModuleLoadRequest) +} + +::google::protobuf::uint8* MemModuleLoadRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.MemModuleLoadRequest) + // required .bgs.protocol.ContentHandle handle = 1; + if (has_handle()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->handle(), target); + } + + // required bytes key = 2; + if (has_key()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 2, this->key(), target); + } + + // required bytes input = 3; + if (has_input()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 3, this->input(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.MemModuleLoadRequest) + return target; +} + +int MemModuleLoadRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.ContentHandle handle = 1; + if (has_handle()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->handle()); + } + + // required bytes key = 2; + if (has_key()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->key()); + } + + // required bytes input = 3; + if (has_input()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->input()); + } + + } + 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 MemModuleLoadRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const MemModuleLoadRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void MemModuleLoadRequest::MergeFrom(const MemModuleLoadRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_handle()) { + mutable_handle()->::bgs::protocol::ContentHandle::MergeFrom(from.handle()); + } + if (from.has_key()) { + set_key(from.key()); + } + if (from.has_input()) { + set_input(from.input()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void MemModuleLoadRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MemModuleLoadRequest::CopyFrom(const MemModuleLoadRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MemModuleLoadRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + if (has_handle()) { + if (!this->handle().IsInitialized()) return false; + } + return true; +} + +void MemModuleLoadRequest::Swap(MemModuleLoadRequest* other) { + if (other != this) { + std::swap(handle_, other->handle_); + std::swap(key_, other->key_); + std::swap(input_, other->input_); + 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 MemModuleLoadRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = MemModuleLoadRequest_descriptor_; + metadata.reflection = MemModuleLoadRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int MemModuleLoadResponse::kDataFieldNumber; +#endif // !_MSC_VER + +MemModuleLoadResponse::MemModuleLoadResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.MemModuleLoadResponse) +} + +void MemModuleLoadResponse::InitAsDefaultInstance() { +} + +MemModuleLoadResponse::MemModuleLoadResponse(const MemModuleLoadResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.MemModuleLoadResponse) +} + +void MemModuleLoadResponse::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +MemModuleLoadResponse::~MemModuleLoadResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.MemModuleLoadResponse) + SharedDtor(); +} + +void MemModuleLoadResponse::SharedDtor() { + if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete data_; + } + if (this != default_instance_) { + } +} + +void MemModuleLoadResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* MemModuleLoadResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return MemModuleLoadResponse_descriptor_; +} + +const MemModuleLoadResponse& MemModuleLoadResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto(); + return *default_instance_; +} + +MemModuleLoadResponse* MemModuleLoadResponse::default_instance_ = NULL; + +MemModuleLoadResponse* MemModuleLoadResponse::New() const { + return new MemModuleLoadResponse; +} + +void MemModuleLoadResponse::Clear() { + if (has_data()) { + if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_->clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool MemModuleLoadResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.MemModuleLoadResponse) + 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)) { + // required bytes data = 1; + case 1: { + if (tag == 10) { + 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:bgs.protocol.authentication.v1.MemModuleLoadResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.MemModuleLoadResponse) + return false; +#undef DO_ +} + +void MemModuleLoadResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.MemModuleLoadResponse) + // required bytes data = 1; + if (has_data()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 1, this->data(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.MemModuleLoadResponse) +} + +::google::protobuf::uint8* MemModuleLoadResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.MemModuleLoadResponse) + // required bytes data = 1; + if (has_data()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 1, this->data(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.MemModuleLoadResponse) + return target; +} + +int MemModuleLoadResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required bytes data = 1; + 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 MemModuleLoadResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const MemModuleLoadResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void MemModuleLoadResponse::MergeFrom(const MemModuleLoadResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_data()) { + set_data(from.data()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void MemModuleLoadResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MemModuleLoadResponse::CopyFrom(const MemModuleLoadResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MemModuleLoadResponse::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void MemModuleLoadResponse::Swap(MemModuleLoadResponse* other) { + if (other != this) { + 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 MemModuleLoadResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = MemModuleLoadResponse_descriptor_; + metadata.reflection = MemModuleLoadResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int SelectGameAccountRequest::kGameAccountIdFieldNumber; +#endif // !_MSC_VER + +SelectGameAccountRequest::SelectGameAccountRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.SelectGameAccountRequest) +} + +void SelectGameAccountRequest::InitAsDefaultInstance() { + game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +SelectGameAccountRequest::SelectGameAccountRequest(const SelectGameAccountRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.SelectGameAccountRequest) +} + +void SelectGameAccountRequest::SharedCtor() { + _cached_size_ = 0; + game_account_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +SelectGameAccountRequest::~SelectGameAccountRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.SelectGameAccountRequest) + SharedDtor(); +} + +void SelectGameAccountRequest::SharedDtor() { + if (this != default_instance_) { + delete game_account_id_; + } +} + +void SelectGameAccountRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SelectGameAccountRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SelectGameAccountRequest_descriptor_; +} + +const SelectGameAccountRequest& SelectGameAccountRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto(); + return *default_instance_; +} + +SelectGameAccountRequest* SelectGameAccountRequest::default_instance_ = NULL; + +SelectGameAccountRequest* SelectGameAccountRequest::New() const { + return new SelectGameAccountRequest; +} + +void SelectGameAccountRequest::Clear() { + if (has_game_account_id()) { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool SelectGameAccountRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.SelectGameAccountRequest) + 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)) { + // required .bgs.protocol.EntityId game_account_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account_id())); + } 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:bgs.protocol.authentication.v1.SelectGameAccountRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.SelectGameAccountRequest) + return false; +#undef DO_ +} + +void SelectGameAccountRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.SelectGameAccountRequest) + // required .bgs.protocol.EntityId game_account_id = 1; + if (has_game_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->game_account_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.SelectGameAccountRequest) +} + +::google::protobuf::uint8* SelectGameAccountRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.SelectGameAccountRequest) + // required .bgs.protocol.EntityId game_account_id = 1; + if (has_game_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->game_account_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.SelectGameAccountRequest) + return target; +} + +int SelectGameAccountRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.EntityId game_account_id = 1; + if (has_game_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void SelectGameAccountRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const SelectGameAccountRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void SelectGameAccountRequest::MergeFrom(const SelectGameAccountRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_game_account_id()) { + mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void SelectGameAccountRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SelectGameAccountRequest::CopyFrom(const SelectGameAccountRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SelectGameAccountRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_game_account_id()) { + if (!this->game_account_id().IsInitialized()) return false; + } + return true; +} + +void SelectGameAccountRequest::Swap(SelectGameAccountRequest* other) { + if (other != this) { + std::swap(game_account_id_, other->game_account_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata SelectGameAccountRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SelectGameAccountRequest_descriptor_; + metadata.reflection = SelectGameAccountRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GameAccountSelectedRequest::kResultFieldNumber; +const int GameAccountSelectedRequest::kGameAccountIdFieldNumber; +#endif // !_MSC_VER + +GameAccountSelectedRequest::GameAccountSelectedRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.GameAccountSelectedRequest) +} + +void GameAccountSelectedRequest::InitAsDefaultInstance() { + game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +GameAccountSelectedRequest::GameAccountSelectedRequest(const GameAccountSelectedRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.GameAccountSelectedRequest) +} + +void GameAccountSelectedRequest::SharedCtor() { + _cached_size_ = 0; + result_ = 0u; + game_account_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameAccountSelectedRequest::~GameAccountSelectedRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.GameAccountSelectedRequest) + SharedDtor(); +} + +void GameAccountSelectedRequest::SharedDtor() { + if (this != default_instance_) { + delete game_account_id_; + } +} + +void GameAccountSelectedRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GameAccountSelectedRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GameAccountSelectedRequest_descriptor_; +} + +const GameAccountSelectedRequest& GameAccountSelectedRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto(); + return *default_instance_; +} + +GameAccountSelectedRequest* GameAccountSelectedRequest::default_instance_ = NULL; + +GameAccountSelectedRequest* GameAccountSelectedRequest::New() const { + return new GameAccountSelectedRequest; +} + +void GameAccountSelectedRequest::Clear() { + if (_has_bits_[0 / 32] & 3) { + result_ = 0u; + if (has_game_account_id()) { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GameAccountSelectedRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.GameAccountSelectedRequest) + 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)) { + // required uint32 result = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &result_))); + set_has_result(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_game_account_id; + break; + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + case 2: { + if (tag == 18) { + parse_game_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account_id())); + } 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:bgs.protocol.authentication.v1.GameAccountSelectedRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.GameAccountSelectedRequest) + return false; +#undef DO_ +} + +void GameAccountSelectedRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.GameAccountSelectedRequest) + // required uint32 result = 1; + if (has_result()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->result(), output); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->game_account_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.GameAccountSelectedRequest) +} + +::google::protobuf::uint8* GameAccountSelectedRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.GameAccountSelectedRequest) + // required uint32 result = 1; + if (has_result()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->result(), target); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->game_account_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.GameAccountSelectedRequest) + return target; +} + +int GameAccountSelectedRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required uint32 result = 1; + if (has_result()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->result()); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void GameAccountSelectedRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GameAccountSelectedRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GameAccountSelectedRequest::MergeFrom(const GameAccountSelectedRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_result()) { + set_result(from.result()); + } + if (from.has_game_account_id()) { + mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GameAccountSelectedRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GameAccountSelectedRequest::CopyFrom(const GameAccountSelectedRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameAccountSelectedRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_game_account_id()) { + if (!this->game_account_id().IsInitialized()) return false; + } + return true; +} + +void GameAccountSelectedRequest::Swap(GameAccountSelectedRequest* other) { + if (other != this) { + std::swap(result_, other->result_); + std::swap(game_account_id_, other->game_account_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata GameAccountSelectedRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GameAccountSelectedRequest_descriptor_; + metadata.reflection = GameAccountSelectedRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GenerateWebCredentialsRequest::kProgramFieldNumber; +#endif // !_MSC_VER + +GenerateWebCredentialsRequest::GenerateWebCredentialsRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest) +} + +void GenerateWebCredentialsRequest::InitAsDefaultInstance() { +} + +GenerateWebCredentialsRequest::GenerateWebCredentialsRequest(const GenerateWebCredentialsRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest) +} + +void GenerateWebCredentialsRequest::SharedCtor() { + _cached_size_ = 0; + program_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GenerateWebCredentialsRequest::~GenerateWebCredentialsRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest) + SharedDtor(); +} + +void GenerateWebCredentialsRequest::SharedDtor() { + if (this != default_instance_) { + } +} + +void GenerateWebCredentialsRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GenerateWebCredentialsRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GenerateWebCredentialsRequest_descriptor_; +} + +const GenerateWebCredentialsRequest& GenerateWebCredentialsRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto(); + return *default_instance_; +} + +GenerateWebCredentialsRequest* GenerateWebCredentialsRequest::default_instance_ = NULL; + +GenerateWebCredentialsRequest* GenerateWebCredentialsRequest::New() const { + return new GenerateWebCredentialsRequest; +} + +void GenerateWebCredentialsRequest::Clear() { + program_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GenerateWebCredentialsRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest) + 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 program = 1; + case 1: { + if (tag == 13) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &program_))); + set_has_program(); + } 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:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest) + return false; +#undef DO_ +} + +void GenerateWebCredentialsRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest) + // optional fixed32 program = 1; + if (has_program()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->program(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest) +} + +::google::protobuf::uint8* GenerateWebCredentialsRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest) + // optional fixed32 program = 1; + if (has_program()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->program(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest) + return target; +} + +int GenerateWebCredentialsRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional fixed32 program = 1; + if (has_program()) { + 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 GenerateWebCredentialsRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GenerateWebCredentialsRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GenerateWebCredentialsRequest::MergeFrom(const GenerateWebCredentialsRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_program()) { + set_program(from.program()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GenerateWebCredentialsRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GenerateWebCredentialsRequest::CopyFrom(const GenerateWebCredentialsRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GenerateWebCredentialsRequest::IsInitialized() const { + + return true; +} + +void GenerateWebCredentialsRequest::Swap(GenerateWebCredentialsRequest* other) { + if (other != this) { + std::swap(program_, other->program_); + 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 GenerateWebCredentialsRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GenerateWebCredentialsRequest_descriptor_; + metadata.reflection = GenerateWebCredentialsRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GenerateWebCredentialsResponse::kWebCredentialsFieldNumber; +#endif // !_MSC_VER + +GenerateWebCredentialsResponse::GenerateWebCredentialsResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse) +} + +void GenerateWebCredentialsResponse::InitAsDefaultInstance() { +} + +GenerateWebCredentialsResponse::GenerateWebCredentialsResponse(const GenerateWebCredentialsResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse) +} + +void GenerateWebCredentialsResponse::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + web_credentials_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GenerateWebCredentialsResponse::~GenerateWebCredentialsResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse) + SharedDtor(); +} + +void GenerateWebCredentialsResponse::SharedDtor() { + if (web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete web_credentials_; + } + if (this != default_instance_) { + } +} + +void GenerateWebCredentialsResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GenerateWebCredentialsResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GenerateWebCredentialsResponse_descriptor_; +} + +const GenerateWebCredentialsResponse& GenerateWebCredentialsResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto(); + return *default_instance_; +} + +GenerateWebCredentialsResponse* GenerateWebCredentialsResponse::default_instance_ = NULL; + +GenerateWebCredentialsResponse* GenerateWebCredentialsResponse::New() const { + return new GenerateWebCredentialsResponse; +} + +void GenerateWebCredentialsResponse::Clear() { + if (has_web_credentials()) { + if (web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + web_credentials_->clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GenerateWebCredentialsResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse) + 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 web_credentials = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_web_credentials())); + } 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:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse) + return false; +#undef DO_ +} + +void GenerateWebCredentialsResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse) + // optional bytes web_credentials = 1; + if (has_web_credentials()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 1, this->web_credentials(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse) +} + +::google::protobuf::uint8* GenerateWebCredentialsResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse) + // optional bytes web_credentials = 1; + if (has_web_credentials()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 1, this->web_credentials(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse) + return target; +} + +int GenerateWebCredentialsResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional bytes web_credentials = 1; + if (has_web_credentials()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->web_credentials()); + } + + } + 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 GenerateWebCredentialsResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GenerateWebCredentialsResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GenerateWebCredentialsResponse::MergeFrom(const GenerateWebCredentialsResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_web_credentials()) { + set_web_credentials(from.web_credentials()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GenerateWebCredentialsResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GenerateWebCredentialsResponse::CopyFrom(const GenerateWebCredentialsResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GenerateWebCredentialsResponse::IsInitialized() const { + + return true; +} + +void GenerateWebCredentialsResponse::Swap(GenerateWebCredentialsResponse* other) { + if (other != this) { + std::swap(web_credentials_, other->web_credentials_); + 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 GenerateWebCredentialsResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GenerateWebCredentialsResponse_descriptor_; + metadata.reflection = GenerateWebCredentialsResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int VerifyWebCredentialsRequest::kWebCredentialsFieldNumber; +#endif // !_MSC_VER + +VerifyWebCredentialsRequest::VerifyWebCredentialsRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest) +} + +void VerifyWebCredentialsRequest::InitAsDefaultInstance() { +} + +VerifyWebCredentialsRequest::VerifyWebCredentialsRequest(const VerifyWebCredentialsRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest) +} + +void VerifyWebCredentialsRequest::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + web_credentials_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +VerifyWebCredentialsRequest::~VerifyWebCredentialsRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest) + SharedDtor(); +} + +void VerifyWebCredentialsRequest::SharedDtor() { + if (web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete web_credentials_; + } + if (this != default_instance_) { + } +} + +void VerifyWebCredentialsRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* VerifyWebCredentialsRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return VerifyWebCredentialsRequest_descriptor_; +} + +const VerifyWebCredentialsRequest& VerifyWebCredentialsRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto(); + return *default_instance_; +} + +VerifyWebCredentialsRequest* VerifyWebCredentialsRequest::default_instance_ = NULL; + +VerifyWebCredentialsRequest* VerifyWebCredentialsRequest::New() const { + return new VerifyWebCredentialsRequest; +} + +void VerifyWebCredentialsRequest::Clear() { + if (has_web_credentials()) { + if (web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + web_credentials_->clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool VerifyWebCredentialsRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest) + 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 web_credentials = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_web_credentials())); + } 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:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest) + return false; +#undef DO_ +} + +void VerifyWebCredentialsRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest) + // optional bytes web_credentials = 1; + if (has_web_credentials()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 1, this->web_credentials(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest) +} + +::google::protobuf::uint8* VerifyWebCredentialsRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest) + // optional bytes web_credentials = 1; + if (has_web_credentials()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 1, this->web_credentials(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest) + return target; +} + +int VerifyWebCredentialsRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional bytes web_credentials = 1; + if (has_web_credentials()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->web_credentials()); + } + + } + 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 VerifyWebCredentialsRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const VerifyWebCredentialsRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void VerifyWebCredentialsRequest::MergeFrom(const VerifyWebCredentialsRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_web_credentials()) { + set_web_credentials(from.web_credentials()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void VerifyWebCredentialsRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void VerifyWebCredentialsRequest::CopyFrom(const VerifyWebCredentialsRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VerifyWebCredentialsRequest::IsInitialized() const { + + return true; +} + +void VerifyWebCredentialsRequest::Swap(VerifyWebCredentialsRequest* other) { + if (other != this) { + std::swap(web_credentials_, other->web_credentials_); + 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 VerifyWebCredentialsRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = VerifyWebCredentialsRequest_descriptor_; + metadata.reflection = VerifyWebCredentialsRequest_reflection_; + return metadata; +} + + +// =================================================================== + +google::protobuf::ServiceDescriptor const* AuthenticationListener::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AuthenticationListener_descriptor_; +} + +void AuthenticationListener::OnModuleLoad(::bgs::protocol::authentication::v1::ModuleLoadRequest const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationListener.OnModuleLoad(bgs.protocol.authentication.v1.ModuleLoadRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 1, request); +} + +void AuthenticationListener::OnModuleMessage(::bgs::protocol::authentication::v1::ModuleMessageRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationListener.OnModuleMessage(bgs.protocol.authentication.v1.ModuleMessageRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 2, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AuthenticationListener::OnServerStateChange(::bgs::protocol::authentication::v1::ServerStateChangeRequest const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationListener.OnServerStateChange(bgs.protocol.authentication.v1.ServerStateChangeRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 4, request); +} + +void AuthenticationListener::OnLogonComplete(::bgs::protocol::authentication::v1::LogonResult const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationListener.OnLogonComplete(bgs.protocol.authentication.v1.LogonResult{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 5, request); +} + +void AuthenticationListener::OnMemModuleLoad(::bgs::protocol::authentication::v1::MemModuleLoadRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationListener.OnMemModuleLoad(bgs.protocol.authentication.v1.MemModuleLoadRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 6, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::authentication::v1::MemModuleLoadResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AuthenticationListener::OnLogonUpdate(::bgs::protocol::authentication::v1::LogonUpdateRequest const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationListener.OnLogonUpdate(bgs.protocol.authentication.v1.LogonUpdateRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 10, request); +} + +void AuthenticationListener::OnVersionInfoUpdated(::bgs::protocol::authentication::v1::VersionInfoNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationListener.OnVersionInfoUpdated(bgs.protocol.authentication.v1.VersionInfoNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 11, request); +} + +void AuthenticationListener::OnLogonQueueUpdate(::bgs::protocol::authentication::v1::LogonQueueUpdateRequest const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationListener.OnLogonQueueUpdate(bgs.protocol.authentication.v1.LogonQueueUpdateRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 12, request); +} + +void AuthenticationListener::OnLogonQueueEnd(::bgs::protocol::NoData const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationListener.OnLogonQueueEnd(bgs.protocol.NoData{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 13, request); +} + +void AuthenticationListener::OnGameAccountSelected(::bgs::protocol::authentication::v1::GameAccountSelectedRequest const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationListener.OnGameAccountSelected(bgs.protocol.authentication.v1.GameAccountSelectedRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 14, request); +} + +void AuthenticationListener::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) { + switch(methodId) { + case 1: { + ::bgs::protocol::authentication::v1::ModuleLoadRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationListener.OnModuleLoad server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnModuleLoad(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationListener.OnModuleLoad(bgs.protocol.authentication.v1.ModuleLoadRequest{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 1, token, status); + break; + } + case 2: { + ::bgs::protocol::authentication::v1::ModuleMessageRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationListener.OnModuleMessage server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleOnModuleMessage(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationListener.OnModuleMessage(bgs.protocol.authentication.v1.ModuleMessageRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 2, token, &response); + else + SendResponse(service_hash_, 2, token, status); + break; + } + case 4: { + ::bgs::protocol::authentication::v1::ServerStateChangeRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationListener.OnServerStateChange server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnServerStateChange(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationListener.OnServerStateChange(bgs.protocol.authentication.v1.ServerStateChangeRequest{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 4, token, status); + break; + } + case 5: { + ::bgs::protocol::authentication::v1::LogonResult request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationListener.OnLogonComplete server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 5, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnLogonComplete(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationListener.OnLogonComplete(bgs.protocol.authentication.v1.LogonResult{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 5, token, status); + break; + } + case 6: { + ::bgs::protocol::authentication::v1::MemModuleLoadRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationListener.OnMemModuleLoad server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 6, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::authentication::v1::MemModuleLoadResponse response; + uint32 status = HandleOnMemModuleLoad(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationListener.OnMemModuleLoad(bgs.protocol.authentication.v1.MemModuleLoadRequest{ %s }) returned bgs.protocol.authentication.v1.MemModuleLoadResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 6, token, &response); + else + SendResponse(service_hash_, 6, token, status); + break; + } + case 10: { + ::bgs::protocol::authentication::v1::LogonUpdateRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationListener.OnLogonUpdate server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 10, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnLogonUpdate(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationListener.OnLogonUpdate(bgs.protocol.authentication.v1.LogonUpdateRequest{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 10, token, status); + break; + } + case 11: { + ::bgs::protocol::authentication::v1::VersionInfoNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationListener.OnVersionInfoUpdated server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 11, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnVersionInfoUpdated(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationListener.OnVersionInfoUpdated(bgs.protocol.authentication.v1.VersionInfoNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 11, token, status); + break; + } + case 12: { + ::bgs::protocol::authentication::v1::LogonQueueUpdateRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationListener.OnLogonQueueUpdate server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 12, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnLogonQueueUpdate(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationListener.OnLogonQueueUpdate(bgs.protocol.authentication.v1.LogonQueueUpdateRequest{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 12, token, status); + break; + } + case 13: { + ::bgs::protocol::NoData request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationListener.OnLogonQueueEnd server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 13, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnLogonQueueEnd(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationListener.OnLogonQueueEnd(bgs.protocol.NoData{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 13, token, status); + break; + } + case 14: { + ::bgs::protocol::authentication::v1::GameAccountSelectedRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationListener.OnGameAccountSelected server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 14, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnGameAccountSelected(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationListener.OnGameAccountSelected(bgs.protocol.authentication.v1.GameAccountSelectedRequest{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 14, token, status); + break; + } + default: + TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId); + SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD); + break; + } +} + +uint32 AuthenticationListener::HandleOnModuleLoad(::bgs::protocol::authentication::v1::ModuleLoadRequest const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationListener.OnModuleLoad({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AuthenticationListener::HandleOnModuleMessage(::bgs::protocol::authentication::v1::ModuleMessageRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationListener.OnModuleMessage({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AuthenticationListener::HandleOnServerStateChange(::bgs::protocol::authentication::v1::ServerStateChangeRequest const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationListener.OnServerStateChange({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AuthenticationListener::HandleOnLogonComplete(::bgs::protocol::authentication::v1::LogonResult const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationListener.OnLogonComplete({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AuthenticationListener::HandleOnMemModuleLoad(::bgs::protocol::authentication::v1::MemModuleLoadRequest const* request, ::bgs::protocol::authentication::v1::MemModuleLoadResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationListener.OnMemModuleLoad({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AuthenticationListener::HandleOnLogonUpdate(::bgs::protocol::authentication::v1::LogonUpdateRequest const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationListener.OnLogonUpdate({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AuthenticationListener::HandleOnVersionInfoUpdated(::bgs::protocol::authentication::v1::VersionInfoNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationListener.OnVersionInfoUpdated({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AuthenticationListener::HandleOnLogonQueueUpdate(::bgs::protocol::authentication::v1::LogonQueueUpdateRequest const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationListener.OnLogonQueueUpdate({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AuthenticationListener::HandleOnLogonQueueEnd(::bgs::protocol::NoData const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationListener.OnLogonQueueEnd({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AuthenticationListener::HandleOnGameAccountSelected(::bgs::protocol::authentication::v1::GameAccountSelectedRequest const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationListener.OnGameAccountSelected({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +// =================================================================== + +google::protobuf::ServiceDescriptor const* AuthenticationService::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AuthenticationService_descriptor_; +} + +void AuthenticationService::Logon(::bgs::protocol::authentication::v1::LogonRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationService.Logon(bgs.protocol.authentication.v1.LogonRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 1, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AuthenticationService::ModuleNotify(::bgs::protocol::authentication::v1::ModuleNotification const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationService.ModuleNotify(bgs.protocol.authentication.v1.ModuleNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 2, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AuthenticationService::ModuleMessage(::bgs::protocol::authentication::v1::ModuleMessageRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationService.ModuleMessage(bgs.protocol.authentication.v1.ModuleMessageRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 3, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AuthenticationService::SelectGameAccount_DEPRECATED(::bgs::protocol::EntityId const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationService.SelectGameAccount_DEPRECATED(bgs.protocol.EntityId{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 4, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AuthenticationService::GenerateSSOToken(::bgs::protocol::authentication::v1::GenerateSSOTokenRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationService.GenerateSSOToken(bgs.protocol.authentication.v1.GenerateSSOTokenRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 5, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::authentication::v1::GenerateSSOTokenResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AuthenticationService::SelectGameAccount(::bgs::protocol::authentication::v1::SelectGameAccountRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationService.SelectGameAccount(bgs.protocol.authentication.v1.SelectGameAccountRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 6, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AuthenticationService::VerifyWebCredentials(::bgs::protocol::authentication::v1::VerifyWebCredentialsRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationService.VerifyWebCredentials(bgs.protocol.authentication.v1.VerifyWebCredentialsRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 7, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AuthenticationService::GenerateWebCredentials(::bgs::protocol::authentication::v1::GenerateWebCredentialsRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationService.GenerateWebCredentials(bgs.protocol.authentication.v1.GenerateWebCredentialsRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 8, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::authentication::v1::GenerateWebCredentialsResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void AuthenticationService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) { + switch(methodId) { + case 1: { + ::bgs::protocol::authentication::v1::LogonRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationService.Logon server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleLogon(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationService.Logon(bgs.protocol.authentication.v1.LogonRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 1, token, &response); + else + SendResponse(service_hash_, 1, token, status); + break; + } + case 2: { + ::bgs::protocol::authentication::v1::ModuleNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationService.ModuleNotify server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleModuleNotify(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationService.ModuleNotify(bgs.protocol.authentication.v1.ModuleNotification{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 2, token, &response); + else + SendResponse(service_hash_, 2, token, status); + break; + } + case 3: { + ::bgs::protocol::authentication::v1::ModuleMessageRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationService.ModuleMessage server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleModuleMessage(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationService.ModuleMessage(bgs.protocol.authentication.v1.ModuleMessageRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 3, token, &response); + else + SendResponse(service_hash_, 3, token, status); + break; + } + case 4: { + ::bgs::protocol::EntityId request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationService.SelectGameAccount_DEPRECATED server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleSelectGameAccount_DEPRECATED(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationService.SelectGameAccount_DEPRECATED(bgs.protocol.EntityId{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 4, token, &response); + else + SendResponse(service_hash_, 4, token, status); + break; + } + case 5: { + ::bgs::protocol::authentication::v1::GenerateSSOTokenRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationService.GenerateSSOToken server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 5, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::authentication::v1::GenerateSSOTokenResponse response; + uint32 status = HandleGenerateSSOToken(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationService.GenerateSSOToken(bgs.protocol.authentication.v1.GenerateSSOTokenRequest{ %s }) returned bgs.protocol.authentication.v1.GenerateSSOTokenResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 5, token, &response); + else + SendResponse(service_hash_, 5, token, status); + break; + } + case 6: { + ::bgs::protocol::authentication::v1::SelectGameAccountRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationService.SelectGameAccount server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 6, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleSelectGameAccount(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationService.SelectGameAccount(bgs.protocol.authentication.v1.SelectGameAccountRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 6, token, &response); + else + SendResponse(service_hash_, 6, token, status); + break; + } + case 7: { + ::bgs::protocol::authentication::v1::VerifyWebCredentialsRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationService.VerifyWebCredentials server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 7, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleVerifyWebCredentials(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationService.VerifyWebCredentials(bgs.protocol.authentication.v1.VerifyWebCredentialsRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 7, token, &response); + else + SendResponse(service_hash_, 7, token, status); + break; + } + case 8: { + ::bgs::protocol::authentication::v1::GenerateWebCredentialsRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationService.GenerateWebCredentials server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 8, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::authentication::v1::GenerateWebCredentialsResponse response; + uint32 status = HandleGenerateWebCredentials(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationService.GenerateWebCredentials(bgs.protocol.authentication.v1.GenerateWebCredentialsRequest{ %s }) returned bgs.protocol.authentication.v1.GenerateWebCredentialsResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 8, token, &response); + else + SendResponse(service_hash_, 8, token, status); + break; + } + default: + TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId); + SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD); + break; + } +} + +uint32 AuthenticationService::HandleLogon(::bgs::protocol::authentication::v1::LogonRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationService.Logon({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AuthenticationService::HandleModuleNotify(::bgs::protocol::authentication::v1::ModuleNotification const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationService.ModuleNotify({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AuthenticationService::HandleModuleMessage(::bgs::protocol::authentication::v1::ModuleMessageRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationService.ModuleMessage({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AuthenticationService::HandleSelectGameAccount_DEPRECATED(::bgs::protocol::EntityId const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationService.SelectGameAccount_DEPRECATED({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AuthenticationService::HandleGenerateSSOToken(::bgs::protocol::authentication::v1::GenerateSSOTokenRequest const* request, ::bgs::protocol::authentication::v1::GenerateSSOTokenResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationService.GenerateSSOToken({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AuthenticationService::HandleSelectGameAccount(::bgs::protocol::authentication::v1::SelectGameAccountRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationService.SelectGameAccount({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AuthenticationService::HandleVerifyWebCredentials(::bgs::protocol::authentication::v1::VerifyWebCredentialsRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationService.VerifyWebCredentials({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 AuthenticationService::HandleGenerateWebCredentials(::bgs::protocol::authentication::v1::GenerateWebCredentialsRequest const* request, ::bgs::protocol::authentication::v1::GenerateWebCredentialsResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationService.GenerateWebCredentials({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace authentication +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/authentication_service.pb.h b/src/server/proto/Client/authentication_service.pb.h new file mode 100644 index 00000000000..1b46a60ed60 --- /dev/null +++ b/src/server/proto/Client/authentication_service.pb.h @@ -0,0 +1,5043 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: authentication_service.proto + +#ifndef PROTOBUF_authentication_5fservice_2eproto__INCLUDED +#define PROTOBUF_authentication_5fservice_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include "account_types.pb.h" +#include "content_handle_types.pb.h" +#include "entity_types.pb.h" +#include "rpc_types.pb.h" +#include "ServiceBase.h" +#include "MessageBuffer.h" +#include +#include +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { +namespace authentication { +namespace v1 { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto(); +void protobuf_AssignDesc_authentication_5fservice_2eproto(); +void protobuf_ShutdownFile_authentication_5fservice_2eproto(); + +class ModuleLoadRequest; +class ModuleNotification; +class ModuleMessageRequest; +class LogonRequest; +class LogonResult; +class GenerateSSOTokenRequest; +class GenerateSSOTokenResponse; +class LogonUpdateRequest; +class LogonQueueUpdateRequest; +class AccountSettingsNotification; +class ServerStateChangeRequest; +class VersionInfo; +class VersionInfoNotification; +class MemModuleLoadRequest; +class MemModuleLoadResponse; +class SelectGameAccountRequest; +class GameAccountSelectedRequest; +class GenerateWebCredentialsRequest; +class GenerateWebCredentialsResponse; +class VerifyWebCredentialsRequest; + +// =================================================================== + +class TC_SHARED_API ModuleLoadRequest : public ::google::protobuf::Message { + public: + ModuleLoadRequest(); + virtual ~ModuleLoadRequest(); + + ModuleLoadRequest(const ModuleLoadRequest& from); + + inline ModuleLoadRequest& operator=(const ModuleLoadRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ModuleLoadRequest& default_instance(); + + void Swap(ModuleLoadRequest* other); + + // implements Message ---------------------------------------------- + + ModuleLoadRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ModuleLoadRequest& from); + void MergeFrom(const ModuleLoadRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.ContentHandle module_handle = 1; + inline bool has_module_handle() const; + inline void clear_module_handle(); + static const int kModuleHandleFieldNumber = 1; + inline const ::bgs::protocol::ContentHandle& module_handle() const; + inline ::bgs::protocol::ContentHandle* mutable_module_handle(); + inline ::bgs::protocol::ContentHandle* release_module_handle(); + inline void set_allocated_module_handle(::bgs::protocol::ContentHandle* module_handle); + + // optional bytes message = 2; + inline bool has_message() const; + inline void clear_message(); + static const int kMessageFieldNumber = 2; + inline const ::std::string& message() const; + inline void set_message(const ::std::string& value); + inline void set_message(const char* value); + inline void set_message(const void* value, size_t size); + inline ::std::string* mutable_message(); + inline ::std::string* release_message(); + inline void set_allocated_message(::std::string* message); + + // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.ModuleLoadRequest) + private: + inline void set_has_module_handle(); + inline void clear_has_module_handle(); + inline void set_has_message(); + inline void clear_has_message(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::ContentHandle* module_handle_; + ::std::string* message_; + friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto(); + friend void protobuf_AssignDesc_authentication_5fservice_2eproto(); + friend void protobuf_ShutdownFile_authentication_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ModuleLoadRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ModuleNotification : public ::google::protobuf::Message { + public: + ModuleNotification(); + virtual ~ModuleNotification(); + + ModuleNotification(const ModuleNotification& from); + + inline ModuleNotification& operator=(const ModuleNotification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ModuleNotification& default_instance(); + + void Swap(ModuleNotification* other); + + // implements Message ---------------------------------------------- + + ModuleNotification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ModuleNotification& from); + void MergeFrom(const ModuleNotification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional int32 module_id = 2; + inline bool has_module_id() const; + inline void clear_module_id(); + static const int kModuleIdFieldNumber = 2; + inline ::google::protobuf::int32 module_id() const; + inline void set_module_id(::google::protobuf::int32 value); + + // optional uint32 result = 3; + inline bool has_result() const; + inline void clear_result(); + static const int kResultFieldNumber = 3; + inline ::google::protobuf::uint32 result() const; + inline void set_result(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.ModuleNotification) + private: + inline void set_has_module_id(); + inline void clear_has_module_id(); + inline void set_has_result(); + inline void clear_has_result(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::int32 module_id_; + ::google::protobuf::uint32 result_; + friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto(); + friend void protobuf_AssignDesc_authentication_5fservice_2eproto(); + friend void protobuf_ShutdownFile_authentication_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ModuleNotification* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ModuleMessageRequest : public ::google::protobuf::Message { + public: + ModuleMessageRequest(); + virtual ~ModuleMessageRequest(); + + ModuleMessageRequest(const ModuleMessageRequest& from); + + inline ModuleMessageRequest& operator=(const ModuleMessageRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ModuleMessageRequest& default_instance(); + + void Swap(ModuleMessageRequest* other); + + // implements Message ---------------------------------------------- + + ModuleMessageRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ModuleMessageRequest& from); + void MergeFrom(const ModuleMessageRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required int32 module_id = 1; + inline bool has_module_id() const; + inline void clear_module_id(); + static const int kModuleIdFieldNumber = 1; + inline ::google::protobuf::int32 module_id() const; + inline void set_module_id(::google::protobuf::int32 value); + + // optional bytes message = 2; + inline bool has_message() const; + inline void clear_message(); + static const int kMessageFieldNumber = 2; + inline const ::std::string& message() const; + inline void set_message(const ::std::string& value); + inline void set_message(const char* value); + inline void set_message(const void* value, size_t size); + inline ::std::string* mutable_message(); + inline ::std::string* release_message(); + inline void set_allocated_message(::std::string* message); + + // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.ModuleMessageRequest) + private: + inline void set_has_module_id(); + inline void clear_has_module_id(); + inline void set_has_message(); + inline void clear_has_message(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* message_; + ::google::protobuf::int32 module_id_; + friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto(); + friend void protobuf_AssignDesc_authentication_5fservice_2eproto(); + friend void protobuf_ShutdownFile_authentication_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ModuleMessageRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API LogonRequest : public ::google::protobuf::Message { + public: + LogonRequest(); + virtual ~LogonRequest(); + + LogonRequest(const LogonRequest& from); + + inline LogonRequest& operator=(const LogonRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const LogonRequest& default_instance(); + + void Swap(LogonRequest* other); + + // implements Message ---------------------------------------------- + + LogonRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const LogonRequest& from); + void MergeFrom(const LogonRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string program = 1; + inline bool has_program() const; + inline void clear_program(); + static const int kProgramFieldNumber = 1; + inline const ::std::string& program() const; + inline void set_program(const ::std::string& value); + inline void set_program(const char* value); + inline void set_program(const char* value, size_t size); + inline ::std::string* mutable_program(); + inline ::std::string* release_program(); + inline void set_allocated_program(::std::string* program); + + // optional string platform = 2; + inline bool has_platform() const; + inline void clear_platform(); + static const int kPlatformFieldNumber = 2; + inline const ::std::string& platform() const; + inline void set_platform(const ::std::string& value); + inline void set_platform(const char* value); + inline void set_platform(const char* value, size_t size); + inline ::std::string* mutable_platform(); + inline ::std::string* release_platform(); + inline void set_allocated_platform(::std::string* platform); + + // optional string locale = 3; + inline bool has_locale() const; + inline void clear_locale(); + static const int kLocaleFieldNumber = 3; + inline const ::std::string& locale() const; + inline void set_locale(const ::std::string& value); + inline void set_locale(const char* value); + inline void set_locale(const char* value, size_t size); + inline ::std::string* mutable_locale(); + inline ::std::string* release_locale(); + inline void set_allocated_locale(::std::string* locale); + + // optional string email = 4; + inline bool has_email() const; + inline void clear_email(); + static const int kEmailFieldNumber = 4; + inline const ::std::string& email() const; + inline void set_email(const ::std::string& value); + inline void set_email(const char* value); + inline void set_email(const char* value, size_t size); + inline ::std::string* mutable_email(); + inline ::std::string* release_email(); + inline void set_allocated_email(::std::string* email); + + // optional string version = 5; + inline bool has_version() const; + inline void clear_version(); + static const int kVersionFieldNumber = 5; + inline const ::std::string& version() const; + inline void set_version(const ::std::string& value); + inline void set_version(const char* value); + inline void set_version(const char* value, size_t size); + inline ::std::string* mutable_version(); + inline ::std::string* release_version(); + inline void set_allocated_version(::std::string* version); + + // optional int32 application_version = 6; + inline bool has_application_version() const; + inline void clear_application_version(); + static const int kApplicationVersionFieldNumber = 6; + inline ::google::protobuf::int32 application_version() const; + inline void set_application_version(::google::protobuf::int32 value); + + // optional bool public_computer = 7; + inline bool has_public_computer() const; + inline void clear_public_computer(); + static const int kPublicComputerFieldNumber = 7; + inline bool public_computer() const; + inline void set_public_computer(bool value); + + // optional bytes sso_id = 8; + inline bool has_sso_id() const; + inline void clear_sso_id(); + static const int kSsoIdFieldNumber = 8; + inline const ::std::string& sso_id() const; + inline void set_sso_id(const ::std::string& value); + inline void set_sso_id(const char* value); + inline void set_sso_id(const void* value, size_t size); + inline ::std::string* mutable_sso_id(); + inline ::std::string* release_sso_id(); + inline void set_allocated_sso_id(::std::string* sso_id); + + // optional bool disconnect_on_cookie_fail = 9 [default = false]; + inline bool has_disconnect_on_cookie_fail() const; + inline void clear_disconnect_on_cookie_fail(); + static const int kDisconnectOnCookieFailFieldNumber = 9; + inline bool disconnect_on_cookie_fail() const; + inline void set_disconnect_on_cookie_fail(bool value); + + // optional bool allow_logon_queue_notifications = 10 [default = false]; + inline bool has_allow_logon_queue_notifications() const; + inline void clear_allow_logon_queue_notifications(); + static const int kAllowLogonQueueNotificationsFieldNumber = 10; + inline bool allow_logon_queue_notifications() const; + inline void set_allow_logon_queue_notifications(bool value); + + // optional bool web_client_verification = 11 [default = false]; + inline bool has_web_client_verification() const; + inline void clear_web_client_verification(); + static const int kWebClientVerificationFieldNumber = 11; + inline bool web_client_verification() const; + inline void set_web_client_verification(bool value); + + // optional bytes cached_web_credentials = 12; + inline bool has_cached_web_credentials() const; + inline void clear_cached_web_credentials(); + static const int kCachedWebCredentialsFieldNumber = 12; + inline const ::std::string& cached_web_credentials() const; + inline void set_cached_web_credentials(const ::std::string& value); + inline void set_cached_web_credentials(const char* value); + inline void set_cached_web_credentials(const void* value, size_t size); + inline ::std::string* mutable_cached_web_credentials(); + inline ::std::string* release_cached_web_credentials(); + inline void set_allocated_cached_web_credentials(::std::string* cached_web_credentials); + + // optional bool enable_cookie = 13 [default = true]; + inline bool has_enable_cookie() const; + inline void clear_enable_cookie(); + static const int kEnableCookieFieldNumber = 13; + inline bool enable_cookie() const; + inline void set_enable_cookie(bool value); + + // optional string user_agent = 14; + inline bool has_user_agent() const; + inline void clear_user_agent(); + static const int kUserAgentFieldNumber = 14; + inline const ::std::string& user_agent() const; + inline void set_user_agent(const ::std::string& value); + inline void set_user_agent(const char* value); + inline void set_user_agent(const char* value, size_t size); + inline ::std::string* mutable_user_agent(); + inline ::std::string* release_user_agent(); + inline void set_allocated_user_agent(::std::string* user_agent); + + // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.LogonRequest) + private: + inline void set_has_program(); + inline void clear_has_program(); + inline void set_has_platform(); + inline void clear_has_platform(); + inline void set_has_locale(); + inline void clear_has_locale(); + inline void set_has_email(); + inline void clear_has_email(); + inline void set_has_version(); + inline void clear_has_version(); + inline void set_has_application_version(); + inline void clear_has_application_version(); + inline void set_has_public_computer(); + inline void clear_has_public_computer(); + inline void set_has_sso_id(); + inline void clear_has_sso_id(); + inline void set_has_disconnect_on_cookie_fail(); + inline void clear_has_disconnect_on_cookie_fail(); + inline void set_has_allow_logon_queue_notifications(); + inline void clear_has_allow_logon_queue_notifications(); + inline void set_has_web_client_verification(); + inline void clear_has_web_client_verification(); + inline void set_has_cached_web_credentials(); + inline void clear_has_cached_web_credentials(); + inline void set_has_enable_cookie(); + inline void clear_has_enable_cookie(); + inline void set_has_user_agent(); + inline void clear_has_user_agent(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* program_; + ::std::string* platform_; + ::std::string* locale_; + ::std::string* email_; + ::std::string* version_; + ::std::string* sso_id_; + ::google::protobuf::int32 application_version_; + bool public_computer_; + bool disconnect_on_cookie_fail_; + bool allow_logon_queue_notifications_; + bool web_client_verification_; + ::std::string* cached_web_credentials_; + ::std::string* user_agent_; + bool enable_cookie_; + friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto(); + friend void protobuf_AssignDesc_authentication_5fservice_2eproto(); + friend void protobuf_ShutdownFile_authentication_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static LogonRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API LogonResult : public ::google::protobuf::Message { + public: + LogonResult(); + virtual ~LogonResult(); + + LogonResult(const LogonResult& from); + + inline LogonResult& operator=(const LogonResult& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const LogonResult& default_instance(); + + void Swap(LogonResult* other); + + // implements Message ---------------------------------------------- + + LogonResult* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const LogonResult& from); + void MergeFrom(const LogonResult& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required uint32 error_code = 1; + inline bool has_error_code() const; + inline void clear_error_code(); + static const int kErrorCodeFieldNumber = 1; + inline ::google::protobuf::uint32 error_code() const; + inline void set_error_code(::google::protobuf::uint32 value); + + // optional .bgs.protocol.EntityId account_id = 2; + inline bool has_account_id() const; + inline void clear_account_id(); + static const int kAccountIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& account_id() const; + inline ::bgs::protocol::EntityId* mutable_account_id(); + inline ::bgs::protocol::EntityId* release_account_id(); + inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id); + + // repeated .bgs.protocol.EntityId game_account_id = 3; + inline int game_account_id_size() const; + inline void clear_game_account_id(); + static const int kGameAccountIdFieldNumber = 3; + inline const ::bgs::protocol::EntityId& game_account_id(int index) const; + inline ::bgs::protocol::EntityId* mutable_game_account_id(int index); + inline ::bgs::protocol::EntityId* add_game_account_id(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId >& + game_account_id() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId >* + mutable_game_account_id(); + + // optional string email = 4; + inline bool has_email() const; + inline void clear_email(); + static const int kEmailFieldNumber = 4; + inline const ::std::string& email() const; + inline void set_email(const ::std::string& value); + inline void set_email(const char* value); + inline void set_email(const char* value, size_t size); + inline ::std::string* mutable_email(); + inline ::std::string* release_email(); + inline void set_allocated_email(::std::string* email); + + // repeated uint32 available_region = 5; + inline int available_region_size() const; + inline void clear_available_region(); + static const int kAvailableRegionFieldNumber = 5; + inline ::google::protobuf::uint32 available_region(int index) const; + inline void set_available_region(int index, ::google::protobuf::uint32 value); + inline void add_available_region(::google::protobuf::uint32 value); + inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + available_region() const; + inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_available_region(); + + // optional uint32 connected_region = 6; + inline bool has_connected_region() const; + inline void clear_connected_region(); + static const int kConnectedRegionFieldNumber = 6; + inline ::google::protobuf::uint32 connected_region() const; + inline void set_connected_region(::google::protobuf::uint32 value); + + // optional string battle_tag = 7; + inline bool has_battle_tag() const; + inline void clear_battle_tag(); + static const int kBattleTagFieldNumber = 7; + inline const ::std::string& battle_tag() const; + inline void set_battle_tag(const ::std::string& value); + inline void set_battle_tag(const char* value); + inline void set_battle_tag(const char* value, size_t size); + inline ::std::string* mutable_battle_tag(); + inline ::std::string* release_battle_tag(); + inline void set_allocated_battle_tag(::std::string* battle_tag); + + // optional string geoip_country = 8; + inline bool has_geoip_country() const; + inline void clear_geoip_country(); + static const int kGeoipCountryFieldNumber = 8; + inline const ::std::string& geoip_country() const; + inline void set_geoip_country(const ::std::string& value); + inline void set_geoip_country(const char* value); + inline void set_geoip_country(const char* value, size_t size); + inline ::std::string* mutable_geoip_country(); + inline ::std::string* release_geoip_country(); + inline void set_allocated_geoip_country(::std::string* geoip_country); + + // optional bytes session_key = 9; + inline bool has_session_key() const; + inline void clear_session_key(); + static const int kSessionKeyFieldNumber = 9; + inline const ::std::string& session_key() const; + inline void set_session_key(const ::std::string& value); + inline void set_session_key(const char* value); + inline void set_session_key(const void* value, size_t size); + inline ::std::string* mutable_session_key(); + inline ::std::string* release_session_key(); + inline void set_allocated_session_key(::std::string* session_key); + + // optional bool restricted_mode = 10; + inline bool has_restricted_mode() const; + inline void clear_restricted_mode(); + static const int kRestrictedModeFieldNumber = 10; + inline bool restricted_mode() const; + inline void set_restricted_mode(bool value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.LogonResult) + private: + inline void set_has_error_code(); + inline void clear_has_error_code(); + inline void set_has_account_id(); + inline void clear_has_account_id(); + inline void set_has_email(); + inline void clear_has_email(); + inline void set_has_connected_region(); + inline void clear_has_connected_region(); + inline void set_has_battle_tag(); + inline void clear_has_battle_tag(); + inline void set_has_geoip_country(); + inline void clear_has_geoip_country(); + inline void set_has_session_key(); + inline void clear_has_session_key(); + inline void set_has_restricted_mode(); + inline void clear_has_restricted_mode(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* account_id_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId > game_account_id_; + ::google::protobuf::uint32 error_code_; + ::google::protobuf::uint32 connected_region_; + ::std::string* email_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > available_region_; + ::std::string* battle_tag_; + ::std::string* geoip_country_; + ::std::string* session_key_; + bool restricted_mode_; + friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto(); + friend void protobuf_AssignDesc_authentication_5fservice_2eproto(); + friend void protobuf_ShutdownFile_authentication_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static LogonResult* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GenerateSSOTokenRequest : public ::google::protobuf::Message { + public: + GenerateSSOTokenRequest(); + virtual ~GenerateSSOTokenRequest(); + + GenerateSSOTokenRequest(const GenerateSSOTokenRequest& from); + + inline GenerateSSOTokenRequest& operator=(const GenerateSSOTokenRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GenerateSSOTokenRequest& default_instance(); + + void Swap(GenerateSSOTokenRequest* other); + + // implements Message ---------------------------------------------- + + GenerateSSOTokenRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GenerateSSOTokenRequest& from); + void MergeFrom(const GenerateSSOTokenRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional fixed32 program = 1; + inline bool has_program() const; + inline void clear_program(); + static const int kProgramFieldNumber = 1; + inline ::google::protobuf::uint32 program() const; + inline void set_program(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.GenerateSSOTokenRequest) + private: + inline void set_has_program(); + inline void clear_has_program(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 program_; + friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto(); + friend void protobuf_AssignDesc_authentication_5fservice_2eproto(); + friend void protobuf_ShutdownFile_authentication_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GenerateSSOTokenRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GenerateSSOTokenResponse : public ::google::protobuf::Message { + public: + GenerateSSOTokenResponse(); + virtual ~GenerateSSOTokenResponse(); + + GenerateSSOTokenResponse(const GenerateSSOTokenResponse& from); + + inline GenerateSSOTokenResponse& operator=(const GenerateSSOTokenResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GenerateSSOTokenResponse& default_instance(); + + void Swap(GenerateSSOTokenResponse* other); + + // implements Message ---------------------------------------------- + + GenerateSSOTokenResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GenerateSSOTokenResponse& from); + void MergeFrom(const GenerateSSOTokenResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional bytes sso_id = 1; + inline bool has_sso_id() const; + inline void clear_sso_id(); + static const int kSsoIdFieldNumber = 1; + inline const ::std::string& sso_id() const; + inline void set_sso_id(const ::std::string& value); + inline void set_sso_id(const char* value); + inline void set_sso_id(const void* value, size_t size); + inline ::std::string* mutable_sso_id(); + inline ::std::string* release_sso_id(); + inline void set_allocated_sso_id(::std::string* sso_id); + + // optional bytes sso_secret = 2; + inline bool has_sso_secret() const; + inline void clear_sso_secret(); + static const int kSsoSecretFieldNumber = 2; + inline const ::std::string& sso_secret() const; + inline void set_sso_secret(const ::std::string& value); + inline void set_sso_secret(const char* value); + inline void set_sso_secret(const void* value, size_t size); + inline ::std::string* mutable_sso_secret(); + inline ::std::string* release_sso_secret(); + inline void set_allocated_sso_secret(::std::string* sso_secret); + + // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.GenerateSSOTokenResponse) + private: + inline void set_has_sso_id(); + inline void clear_has_sso_id(); + inline void set_has_sso_secret(); + inline void clear_has_sso_secret(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* sso_id_; + ::std::string* sso_secret_; + friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto(); + friend void protobuf_AssignDesc_authentication_5fservice_2eproto(); + friend void protobuf_ShutdownFile_authentication_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GenerateSSOTokenResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API LogonUpdateRequest : public ::google::protobuf::Message { + public: + LogonUpdateRequest(); + virtual ~LogonUpdateRequest(); + + LogonUpdateRequest(const LogonUpdateRequest& from); + + inline LogonUpdateRequest& operator=(const LogonUpdateRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const LogonUpdateRequest& default_instance(); + + void Swap(LogonUpdateRequest* other); + + // implements Message ---------------------------------------------- + + LogonUpdateRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const LogonUpdateRequest& from); + void MergeFrom(const LogonUpdateRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required uint32 error_code = 1; + inline bool has_error_code() const; + inline void clear_error_code(); + static const int kErrorCodeFieldNumber = 1; + inline ::google::protobuf::uint32 error_code() const; + inline void set_error_code(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.LogonUpdateRequest) + private: + inline void set_has_error_code(); + inline void clear_has_error_code(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 error_code_; + friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto(); + friend void protobuf_AssignDesc_authentication_5fservice_2eproto(); + friend void protobuf_ShutdownFile_authentication_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static LogonUpdateRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API LogonQueueUpdateRequest : public ::google::protobuf::Message { + public: + LogonQueueUpdateRequest(); + virtual ~LogonQueueUpdateRequest(); + + LogonQueueUpdateRequest(const LogonQueueUpdateRequest& from); + + inline LogonQueueUpdateRequest& operator=(const LogonQueueUpdateRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const LogonQueueUpdateRequest& default_instance(); + + void Swap(LogonQueueUpdateRequest* other); + + // implements Message ---------------------------------------------- + + LogonQueueUpdateRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const LogonQueueUpdateRequest& from); + void MergeFrom(const LogonQueueUpdateRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required uint32 position = 1; + inline bool has_position() const; + inline void clear_position(); + static const int kPositionFieldNumber = 1; + inline ::google::protobuf::uint32 position() const; + inline void set_position(::google::protobuf::uint32 value); + + // required uint64 estimated_time = 2; + inline bool has_estimated_time() const; + inline void clear_estimated_time(); + static const int kEstimatedTimeFieldNumber = 2; + inline ::google::protobuf::uint64 estimated_time() const; + inline void set_estimated_time(::google::protobuf::uint64 value); + + // required uint64 eta_deviation_in_sec = 3; + inline bool has_eta_deviation_in_sec() const; + inline void clear_eta_deviation_in_sec(); + static const int kEtaDeviationInSecFieldNumber = 3; + inline ::google::protobuf::uint64 eta_deviation_in_sec() const; + inline void set_eta_deviation_in_sec(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.LogonQueueUpdateRequest) + private: + inline void set_has_position(); + inline void clear_has_position(); + inline void set_has_estimated_time(); + inline void clear_has_estimated_time(); + inline void set_has_eta_deviation_in_sec(); + inline void clear_has_eta_deviation_in_sec(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint64 estimated_time_; + ::google::protobuf::uint64 eta_deviation_in_sec_; + ::google::protobuf::uint32 position_; + friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto(); + friend void protobuf_AssignDesc_authentication_5fservice_2eproto(); + friend void protobuf_ShutdownFile_authentication_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static LogonQueueUpdateRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API AccountSettingsNotification : public ::google::protobuf::Message { + public: + AccountSettingsNotification(); + virtual ~AccountSettingsNotification(); + + AccountSettingsNotification(const AccountSettingsNotification& from); + + inline AccountSettingsNotification& operator=(const AccountSettingsNotification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AccountSettingsNotification& default_instance(); + + void Swap(AccountSettingsNotification* other); + + // implements Message ---------------------------------------------- + + AccountSettingsNotification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AccountSettingsNotification& from); + void MergeFrom(const AccountSettingsNotification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.account.v1.AccountLicense licenses = 1; + inline int licenses_size() const; + inline void clear_licenses(); + static const int kLicensesFieldNumber = 1; + inline const ::bgs::protocol::account::v1::AccountLicense& licenses(int index) const; + inline ::bgs::protocol::account::v1::AccountLicense* mutable_licenses(int index); + inline ::bgs::protocol::account::v1::AccountLicense* add_licenses(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >& + licenses() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >* + mutable_licenses(); + + // optional bool is_using_rid = 2; + inline bool has_is_using_rid() const; + inline void clear_is_using_rid(); + static const int kIsUsingRidFieldNumber = 2; + inline bool is_using_rid() const; + inline void set_is_using_rid(bool value); + + // optional bool is_playing_from_igr = 3; + inline bool has_is_playing_from_igr() const; + inline void clear_is_playing_from_igr(); + static const int kIsPlayingFromIgrFieldNumber = 3; + inline bool is_playing_from_igr() const; + inline void set_is_playing_from_igr(bool value); + + // optional bool can_receive_voice = 4; + inline bool has_can_receive_voice() const; + inline void clear_can_receive_voice(); + static const int kCanReceiveVoiceFieldNumber = 4; + inline bool can_receive_voice() const; + inline void set_can_receive_voice(bool value); + + // optional bool can_send_voice = 5; + inline bool has_can_send_voice() const; + inline void clear_can_send_voice(); + static const int kCanSendVoiceFieldNumber = 5; + inline bool can_send_voice() const; + inline void set_can_send_voice(bool value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.AccountSettingsNotification) + private: + inline void set_has_is_using_rid(); + inline void clear_has_is_using_rid(); + inline void set_has_is_playing_from_igr(); + inline void clear_has_is_playing_from_igr(); + inline void set_has_can_receive_voice(); + inline void clear_has_can_receive_voice(); + inline void set_has_can_send_voice(); + inline void clear_has_can_send_voice(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense > licenses_; + bool is_using_rid_; + bool is_playing_from_igr_; + bool can_receive_voice_; + bool can_send_voice_; + friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto(); + friend void protobuf_AssignDesc_authentication_5fservice_2eproto(); + friend void protobuf_ShutdownFile_authentication_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static AccountSettingsNotification* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ServerStateChangeRequest : public ::google::protobuf::Message { + public: + ServerStateChangeRequest(); + virtual ~ServerStateChangeRequest(); + + ServerStateChangeRequest(const ServerStateChangeRequest& from); + + inline ServerStateChangeRequest& operator=(const ServerStateChangeRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ServerStateChangeRequest& default_instance(); + + void Swap(ServerStateChangeRequest* other); + + // implements Message ---------------------------------------------- + + ServerStateChangeRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ServerStateChangeRequest& from); + void MergeFrom(const ServerStateChangeRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required uint32 state = 1; + inline bool has_state() const; + inline void clear_state(); + static const int kStateFieldNumber = 1; + inline ::google::protobuf::uint32 state() const; + inline void set_state(::google::protobuf::uint32 value); + + // required uint64 event_time = 2; + inline bool has_event_time() const; + inline void clear_event_time(); + static const int kEventTimeFieldNumber = 2; + inline ::google::protobuf::uint64 event_time() const; + inline void set_event_time(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.ServerStateChangeRequest) + private: + inline void set_has_state(); + inline void clear_has_state(); + inline void set_has_event_time(); + inline void clear_has_event_time(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint64 event_time_; + ::google::protobuf::uint32 state_; + friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto(); + friend void protobuf_AssignDesc_authentication_5fservice_2eproto(); + friend void protobuf_ShutdownFile_authentication_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ServerStateChangeRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API VersionInfo : public ::google::protobuf::Message { + public: + VersionInfo(); + virtual ~VersionInfo(); + + VersionInfo(const VersionInfo& from); + + inline VersionInfo& operator=(const VersionInfo& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const VersionInfo& default_instance(); + + void Swap(VersionInfo* other); + + // implements Message ---------------------------------------------- + + VersionInfo* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const VersionInfo& from); + void MergeFrom(const VersionInfo& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint32 number = 1; + inline bool has_number() const; + inline void clear_number(); + static const int kNumberFieldNumber = 1; + inline ::google::protobuf::uint32 number() const; + inline void set_number(::google::protobuf::uint32 value); + + // optional string patch = 2; + inline bool has_patch() const; + inline void clear_patch(); + static const int kPatchFieldNumber = 2; + inline const ::std::string& patch() const; + inline void set_patch(const ::std::string& value); + inline void set_patch(const char* value); + inline void set_patch(const char* value, size_t size); + inline ::std::string* mutable_patch(); + inline ::std::string* release_patch(); + inline void set_allocated_patch(::std::string* patch); + + // optional bool is_optional = 3; + inline bool has_is_optional() const; + inline void clear_is_optional(); + static const int kIsOptionalFieldNumber = 3; + inline bool is_optional() const; + inline void set_is_optional(bool value); + + // optional uint64 kick_time = 4; + inline bool has_kick_time() const; + inline void clear_kick_time(); + static const int kKickTimeFieldNumber = 4; + inline ::google::protobuf::uint64 kick_time() const; + inline void set_kick_time(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.VersionInfo) + private: + inline void set_has_number(); + inline void clear_has_number(); + inline void set_has_patch(); + inline void clear_has_patch(); + inline void set_has_is_optional(); + inline void clear_has_is_optional(); + inline void set_has_kick_time(); + inline void clear_has_kick_time(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* patch_; + ::google::protobuf::uint32 number_; + bool is_optional_; + ::google::protobuf::uint64 kick_time_; + friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto(); + friend void protobuf_AssignDesc_authentication_5fservice_2eproto(); + friend void protobuf_ShutdownFile_authentication_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static VersionInfo* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API VersionInfoNotification : public ::google::protobuf::Message { + public: + VersionInfoNotification(); + virtual ~VersionInfoNotification(); + + VersionInfoNotification(const VersionInfoNotification& from); + + inline VersionInfoNotification& operator=(const VersionInfoNotification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const VersionInfoNotification& default_instance(); + + void Swap(VersionInfoNotification* other); + + // implements Message ---------------------------------------------- + + VersionInfoNotification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const VersionInfoNotification& from); + void MergeFrom(const VersionInfoNotification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.authentication.v1.VersionInfo version_info = 1; + inline bool has_version_info() const; + inline void clear_version_info(); + static const int kVersionInfoFieldNumber = 1; + inline const ::bgs::protocol::authentication::v1::VersionInfo& version_info() const; + inline ::bgs::protocol::authentication::v1::VersionInfo* mutable_version_info(); + inline ::bgs::protocol::authentication::v1::VersionInfo* release_version_info(); + inline void set_allocated_version_info(::bgs::protocol::authentication::v1::VersionInfo* version_info); + + // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.VersionInfoNotification) + private: + inline void set_has_version_info(); + inline void clear_has_version_info(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::authentication::v1::VersionInfo* version_info_; + friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto(); + friend void protobuf_AssignDesc_authentication_5fservice_2eproto(); + friend void protobuf_ShutdownFile_authentication_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static VersionInfoNotification* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API MemModuleLoadRequest : public ::google::protobuf::Message { + public: + MemModuleLoadRequest(); + virtual ~MemModuleLoadRequest(); + + MemModuleLoadRequest(const MemModuleLoadRequest& from); + + inline MemModuleLoadRequest& operator=(const MemModuleLoadRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const MemModuleLoadRequest& default_instance(); + + void Swap(MemModuleLoadRequest* other); + + // implements Message ---------------------------------------------- + + MemModuleLoadRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const MemModuleLoadRequest& from); + void MergeFrom(const MemModuleLoadRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.ContentHandle handle = 1; + inline bool has_handle() const; + inline void clear_handle(); + static const int kHandleFieldNumber = 1; + inline const ::bgs::protocol::ContentHandle& handle() const; + inline ::bgs::protocol::ContentHandle* mutable_handle(); + inline ::bgs::protocol::ContentHandle* release_handle(); + inline void set_allocated_handle(::bgs::protocol::ContentHandle* handle); + + // required bytes key = 2; + inline bool has_key() const; + inline void clear_key(); + static const int kKeyFieldNumber = 2; + inline const ::std::string& key() const; + inline void set_key(const ::std::string& value); + inline void set_key(const char* value); + inline void set_key(const void* value, size_t size); + inline ::std::string* mutable_key(); + inline ::std::string* release_key(); + inline void set_allocated_key(::std::string* key); + + // required bytes input = 3; + inline bool has_input() const; + inline void clear_input(); + static const int kInputFieldNumber = 3; + inline const ::std::string& input() const; + inline void set_input(const ::std::string& value); + inline void set_input(const char* value); + inline void set_input(const void* value, size_t size); + inline ::std::string* mutable_input(); + inline ::std::string* release_input(); + inline void set_allocated_input(::std::string* input); + + // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.MemModuleLoadRequest) + private: + inline void set_has_handle(); + inline void clear_has_handle(); + inline void set_has_key(); + inline void clear_has_key(); + inline void set_has_input(); + inline void clear_has_input(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::ContentHandle* handle_; + ::std::string* key_; + ::std::string* input_; + friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto(); + friend void protobuf_AssignDesc_authentication_5fservice_2eproto(); + friend void protobuf_ShutdownFile_authentication_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static MemModuleLoadRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API MemModuleLoadResponse : public ::google::protobuf::Message { + public: + MemModuleLoadResponse(); + virtual ~MemModuleLoadResponse(); + + MemModuleLoadResponse(const MemModuleLoadResponse& from); + + inline MemModuleLoadResponse& operator=(const MemModuleLoadResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const MemModuleLoadResponse& default_instance(); + + void Swap(MemModuleLoadResponse* other); + + // implements Message ---------------------------------------------- + + MemModuleLoadResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const MemModuleLoadResponse& from); + void MergeFrom(const MemModuleLoadResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required bytes data = 1; + inline bool has_data() const; + inline void clear_data(); + static const int kDataFieldNumber = 1; + inline const ::std::string& data() const; + inline void set_data(const ::std::string& value); + inline void set_data(const char* value); + inline void set_data(const void* value, size_t size); + inline ::std::string* mutable_data(); + inline ::std::string* release_data(); + inline void set_allocated_data(::std::string* data); + + // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.MemModuleLoadResponse) + private: + inline void set_has_data(); + inline void clear_has_data(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* data_; + friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto(); + friend void protobuf_AssignDesc_authentication_5fservice_2eproto(); + friend void protobuf_ShutdownFile_authentication_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static MemModuleLoadResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API SelectGameAccountRequest : public ::google::protobuf::Message { + public: + SelectGameAccountRequest(); + virtual ~SelectGameAccountRequest(); + + SelectGameAccountRequest(const SelectGameAccountRequest& from); + + inline SelectGameAccountRequest& operator=(const SelectGameAccountRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SelectGameAccountRequest& default_instance(); + + void Swap(SelectGameAccountRequest* other); + + // implements Message ---------------------------------------------- + + SelectGameAccountRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SelectGameAccountRequest& from); + void MergeFrom(const SelectGameAccountRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.EntityId game_account_id = 1; + inline bool has_game_account_id() const; + inline void clear_game_account_id(); + static const int kGameAccountIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& game_account_id() const; + inline ::bgs::protocol::EntityId* mutable_game_account_id(); + inline ::bgs::protocol::EntityId* release_game_account_id(); + inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id); + + // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.SelectGameAccountRequest) + private: + inline void set_has_game_account_id(); + inline void clear_has_game_account_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* game_account_id_; + friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto(); + friend void protobuf_AssignDesc_authentication_5fservice_2eproto(); + friend void protobuf_ShutdownFile_authentication_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static SelectGameAccountRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GameAccountSelectedRequest : public ::google::protobuf::Message { + public: + GameAccountSelectedRequest(); + virtual ~GameAccountSelectedRequest(); + + GameAccountSelectedRequest(const GameAccountSelectedRequest& from); + + inline GameAccountSelectedRequest& operator=(const GameAccountSelectedRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GameAccountSelectedRequest& default_instance(); + + void Swap(GameAccountSelectedRequest* other); + + // implements Message ---------------------------------------------- + + GameAccountSelectedRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GameAccountSelectedRequest& from); + void MergeFrom(const GameAccountSelectedRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required uint32 result = 1; + inline bool has_result() const; + inline void clear_result(); + static const int kResultFieldNumber = 1; + inline ::google::protobuf::uint32 result() const; + inline void set_result(::google::protobuf::uint32 value); + + // optional .bgs.protocol.EntityId game_account_id = 2; + inline bool has_game_account_id() const; + inline void clear_game_account_id(); + static const int kGameAccountIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& game_account_id() const; + inline ::bgs::protocol::EntityId* mutable_game_account_id(); + inline ::bgs::protocol::EntityId* release_game_account_id(); + inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id); + + // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.GameAccountSelectedRequest) + private: + inline void set_has_result(); + inline void clear_has_result(); + inline void set_has_game_account_id(); + inline void clear_has_game_account_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* game_account_id_; + ::google::protobuf::uint32 result_; + friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto(); + friend void protobuf_AssignDesc_authentication_5fservice_2eproto(); + friend void protobuf_ShutdownFile_authentication_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GameAccountSelectedRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GenerateWebCredentialsRequest : public ::google::protobuf::Message { + public: + GenerateWebCredentialsRequest(); + virtual ~GenerateWebCredentialsRequest(); + + GenerateWebCredentialsRequest(const GenerateWebCredentialsRequest& from); + + inline GenerateWebCredentialsRequest& operator=(const GenerateWebCredentialsRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GenerateWebCredentialsRequest& default_instance(); + + void Swap(GenerateWebCredentialsRequest* other); + + // implements Message ---------------------------------------------- + + GenerateWebCredentialsRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GenerateWebCredentialsRequest& from); + void MergeFrom(const GenerateWebCredentialsRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional fixed32 program = 1; + inline bool has_program() const; + inline void clear_program(); + static const int kProgramFieldNumber = 1; + inline ::google::protobuf::uint32 program() const; + inline void set_program(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest) + private: + inline void set_has_program(); + inline void clear_has_program(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 program_; + friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto(); + friend void protobuf_AssignDesc_authentication_5fservice_2eproto(); + friend void protobuf_ShutdownFile_authentication_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GenerateWebCredentialsRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GenerateWebCredentialsResponse : public ::google::protobuf::Message { + public: + GenerateWebCredentialsResponse(); + virtual ~GenerateWebCredentialsResponse(); + + GenerateWebCredentialsResponse(const GenerateWebCredentialsResponse& from); + + inline GenerateWebCredentialsResponse& operator=(const GenerateWebCredentialsResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GenerateWebCredentialsResponse& default_instance(); + + void Swap(GenerateWebCredentialsResponse* other); + + // implements Message ---------------------------------------------- + + GenerateWebCredentialsResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GenerateWebCredentialsResponse& from); + void MergeFrom(const GenerateWebCredentialsResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional bytes web_credentials = 1; + inline bool has_web_credentials() const; + inline void clear_web_credentials(); + static const int kWebCredentialsFieldNumber = 1; + inline const ::std::string& web_credentials() const; + inline void set_web_credentials(const ::std::string& value); + inline void set_web_credentials(const char* value); + inline void set_web_credentials(const void* value, size_t size); + inline ::std::string* mutable_web_credentials(); + inline ::std::string* release_web_credentials(); + inline void set_allocated_web_credentials(::std::string* web_credentials); + + // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse) + private: + inline void set_has_web_credentials(); + inline void clear_has_web_credentials(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* web_credentials_; + friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto(); + friend void protobuf_AssignDesc_authentication_5fservice_2eproto(); + friend void protobuf_ShutdownFile_authentication_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GenerateWebCredentialsResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API VerifyWebCredentialsRequest : public ::google::protobuf::Message { + public: + VerifyWebCredentialsRequest(); + virtual ~VerifyWebCredentialsRequest(); + + VerifyWebCredentialsRequest(const VerifyWebCredentialsRequest& from); + + inline VerifyWebCredentialsRequest& operator=(const VerifyWebCredentialsRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const VerifyWebCredentialsRequest& default_instance(); + + void Swap(VerifyWebCredentialsRequest* other); + + // implements Message ---------------------------------------------- + + VerifyWebCredentialsRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const VerifyWebCredentialsRequest& from); + void MergeFrom(const VerifyWebCredentialsRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional bytes web_credentials = 1; + inline bool has_web_credentials() const; + inline void clear_web_credentials(); + static const int kWebCredentialsFieldNumber = 1; + inline const ::std::string& web_credentials() const; + inline void set_web_credentials(const ::std::string& value); + inline void set_web_credentials(const char* value); + inline void set_web_credentials(const void* value, size_t size); + inline ::std::string* mutable_web_credentials(); + inline ::std::string* release_web_credentials(); + inline void set_allocated_web_credentials(::std::string* web_credentials); + + // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest) + private: + inline void set_has_web_credentials(); + inline void clear_has_web_credentials(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* web_credentials_; + friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto(); + friend void protobuf_AssignDesc_authentication_5fservice_2eproto(); + friend void protobuf_ShutdownFile_authentication_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static VerifyWebCredentialsRequest* default_instance_; +}; +// =================================================================== + +class TC_SHARED_API AuthenticationListener : public ServiceBase +{ + public: + + template + explicit AuthenticationListener(HashSelector) : service_hash_(HashSelector::Result::value) { } + + typedef std::integral_constant OriginalHash; + typedef std::integral_constant NameHash; + + static google::protobuf::ServiceDescriptor const* descriptor(); + + // client methods -------------------------------------------------- + + void OnModuleLoad(::bgs::protocol::authentication::v1::ModuleLoadRequest const* request); + void OnModuleMessage(::bgs::protocol::authentication::v1::ModuleMessageRequest const* request, std::function responseCallback); + void OnServerStateChange(::bgs::protocol::authentication::v1::ServerStateChangeRequest const* request); + void OnLogonComplete(::bgs::protocol::authentication::v1::LogonResult const* request); + void OnMemModuleLoad(::bgs::protocol::authentication::v1::MemModuleLoadRequest const* request, std::function responseCallback); + void OnLogonUpdate(::bgs::protocol::authentication::v1::LogonUpdateRequest const* request); + void OnVersionInfoUpdated(::bgs::protocol::authentication::v1::VersionInfoNotification const* request); + void OnLogonQueueUpdate(::bgs::protocol::authentication::v1::LogonQueueUpdateRequest const* request); + void OnLogonQueueEnd(::bgs::protocol::NoData const* request); + void OnGameAccountSelected(::bgs::protocol::authentication::v1::GameAccountSelectedRequest const* request); + // server methods -------------------------------------------------- + + void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final; + + protected: + virtual uint32 HandleOnModuleLoad(::bgs::protocol::authentication::v1::ModuleLoadRequest const* request); + virtual uint32 HandleOnModuleMessage(::bgs::protocol::authentication::v1::ModuleMessageRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleOnServerStateChange(::bgs::protocol::authentication::v1::ServerStateChangeRequest const* request); + virtual uint32 HandleOnLogonComplete(::bgs::protocol::authentication::v1::LogonResult const* request); + virtual uint32 HandleOnMemModuleLoad(::bgs::protocol::authentication::v1::MemModuleLoadRequest const* request, ::bgs::protocol::authentication::v1::MemModuleLoadResponse* response); + virtual uint32 HandleOnLogonUpdate(::bgs::protocol::authentication::v1::LogonUpdateRequest const* request); + virtual uint32 HandleOnVersionInfoUpdated(::bgs::protocol::authentication::v1::VersionInfoNotification const* request); + virtual uint32 HandleOnLogonQueueUpdate(::bgs::protocol::authentication::v1::LogonQueueUpdateRequest const* request); + virtual uint32 HandleOnLogonQueueEnd(::bgs::protocol::NoData const* request); + virtual uint32 HandleOnGameAccountSelected(::bgs::protocol::authentication::v1::GameAccountSelectedRequest const* request); + + private: + uint32 service_hash_; + + GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(AuthenticationListener); +}; + +// ------------------------------------------------------------------- + +class TC_SHARED_API AuthenticationService : public ServiceBase +{ + public: + + template + explicit AuthenticationService(HashSelector) : service_hash_(HashSelector::Result::value) { } + + typedef std::integral_constant OriginalHash; + typedef std::integral_constant NameHash; + + static google::protobuf::ServiceDescriptor const* descriptor(); + + // client methods -------------------------------------------------- + + void Logon(::bgs::protocol::authentication::v1::LogonRequest const* request, std::function responseCallback); + void ModuleNotify(::bgs::protocol::authentication::v1::ModuleNotification const* request, std::function responseCallback); + void ModuleMessage(::bgs::protocol::authentication::v1::ModuleMessageRequest const* request, std::function responseCallback); + void SelectGameAccount_DEPRECATED(::bgs::protocol::EntityId const* request, std::function responseCallback); + void GenerateSSOToken(::bgs::protocol::authentication::v1::GenerateSSOTokenRequest const* request, std::function responseCallback); + void SelectGameAccount(::bgs::protocol::authentication::v1::SelectGameAccountRequest const* request, std::function responseCallback); + void VerifyWebCredentials(::bgs::protocol::authentication::v1::VerifyWebCredentialsRequest const* request, std::function responseCallback); + void GenerateWebCredentials(::bgs::protocol::authentication::v1::GenerateWebCredentialsRequest const* request, std::function responseCallback); + // server methods -------------------------------------------------- + + void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final; + + protected: + virtual uint32 HandleLogon(::bgs::protocol::authentication::v1::LogonRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleModuleNotify(::bgs::protocol::authentication::v1::ModuleNotification const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleModuleMessage(::bgs::protocol::authentication::v1::ModuleMessageRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleSelectGameAccount_DEPRECATED(::bgs::protocol::EntityId const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleGenerateSSOToken(::bgs::protocol::authentication::v1::GenerateSSOTokenRequest const* request, ::bgs::protocol::authentication::v1::GenerateSSOTokenResponse* response); + virtual uint32 HandleSelectGameAccount(::bgs::protocol::authentication::v1::SelectGameAccountRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleVerifyWebCredentials(::bgs::protocol::authentication::v1::VerifyWebCredentialsRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleGenerateWebCredentials(::bgs::protocol::authentication::v1::GenerateWebCredentialsRequest const* request, ::bgs::protocol::authentication::v1::GenerateWebCredentialsResponse* response); + + private: + uint32 service_hash_; + + GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(AuthenticationService); +}; + +// =================================================================== + + +// =================================================================== + +// ModuleLoadRequest + +// required .bgs.protocol.ContentHandle module_handle = 1; +inline bool ModuleLoadRequest::has_module_handle() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ModuleLoadRequest::set_has_module_handle() { + _has_bits_[0] |= 0x00000001u; +} +inline void ModuleLoadRequest::clear_has_module_handle() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ModuleLoadRequest::clear_module_handle() { + if (module_handle_ != NULL) module_handle_->::bgs::protocol::ContentHandle::Clear(); + clear_has_module_handle(); +} +inline const ::bgs::protocol::ContentHandle& ModuleLoadRequest::module_handle() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.ModuleLoadRequest.module_handle) + return module_handle_ != NULL ? *module_handle_ : *default_instance_->module_handle_; +} +inline ::bgs::protocol::ContentHandle* ModuleLoadRequest::mutable_module_handle() { + set_has_module_handle(); + if (module_handle_ == NULL) module_handle_ = new ::bgs::protocol::ContentHandle; + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.ModuleLoadRequest.module_handle) + return module_handle_; +} +inline ::bgs::protocol::ContentHandle* ModuleLoadRequest::release_module_handle() { + clear_has_module_handle(); + ::bgs::protocol::ContentHandle* temp = module_handle_; + module_handle_ = NULL; + return temp; +} +inline void ModuleLoadRequest::set_allocated_module_handle(::bgs::protocol::ContentHandle* module_handle) { + delete module_handle_; + module_handle_ = module_handle; + if (module_handle) { + set_has_module_handle(); + } else { + clear_has_module_handle(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.ModuleLoadRequest.module_handle) +} + +// optional bytes message = 2; +inline bool ModuleLoadRequest::has_message() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ModuleLoadRequest::set_has_message() { + _has_bits_[0] |= 0x00000002u; +} +inline void ModuleLoadRequest::clear_has_message() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ModuleLoadRequest::clear_message() { + if (message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + message_->clear(); + } + clear_has_message(); +} +inline const ::std::string& ModuleLoadRequest::message() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.ModuleLoadRequest.message) + return *message_; +} +inline void ModuleLoadRequest::set_message(const ::std::string& value) { + set_has_message(); + if (message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + message_ = new ::std::string; + } + message_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.ModuleLoadRequest.message) +} +inline void ModuleLoadRequest::set_message(const char* value) { + set_has_message(); + if (message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + message_ = new ::std::string; + } + message_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.ModuleLoadRequest.message) +} +inline void ModuleLoadRequest::set_message(const void* value, size_t size) { + set_has_message(); + if (message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + message_ = new ::std::string; + } + message_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.ModuleLoadRequest.message) +} +inline ::std::string* ModuleLoadRequest::mutable_message() { + set_has_message(); + if (message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + message_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.ModuleLoadRequest.message) + return message_; +} +inline ::std::string* ModuleLoadRequest::release_message() { + clear_has_message(); + if (message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = message_; + message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ModuleLoadRequest::set_allocated_message(::std::string* message) { + if (message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete message_; + } + if (message) { + set_has_message(); + message_ = message; + } else { + clear_has_message(); + message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.ModuleLoadRequest.message) +} + +// ------------------------------------------------------------------- + +// ModuleNotification + +// optional int32 module_id = 2; +inline bool ModuleNotification::has_module_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ModuleNotification::set_has_module_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void ModuleNotification::clear_has_module_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ModuleNotification::clear_module_id() { + module_id_ = 0; + clear_has_module_id(); +} +inline ::google::protobuf::int32 ModuleNotification::module_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.ModuleNotification.module_id) + return module_id_; +} +inline void ModuleNotification::set_module_id(::google::protobuf::int32 value) { + set_has_module_id(); + module_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.ModuleNotification.module_id) +} + +// optional uint32 result = 3; +inline bool ModuleNotification::has_result() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ModuleNotification::set_has_result() { + _has_bits_[0] |= 0x00000002u; +} +inline void ModuleNotification::clear_has_result() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ModuleNotification::clear_result() { + result_ = 0u; + clear_has_result(); +} +inline ::google::protobuf::uint32 ModuleNotification::result() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.ModuleNotification.result) + return result_; +} +inline void ModuleNotification::set_result(::google::protobuf::uint32 value) { + set_has_result(); + result_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.ModuleNotification.result) +} + +// ------------------------------------------------------------------- + +// ModuleMessageRequest + +// required int32 module_id = 1; +inline bool ModuleMessageRequest::has_module_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ModuleMessageRequest::set_has_module_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void ModuleMessageRequest::clear_has_module_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ModuleMessageRequest::clear_module_id() { + module_id_ = 0; + clear_has_module_id(); +} +inline ::google::protobuf::int32 ModuleMessageRequest::module_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.ModuleMessageRequest.module_id) + return module_id_; +} +inline void ModuleMessageRequest::set_module_id(::google::protobuf::int32 value) { + set_has_module_id(); + module_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.ModuleMessageRequest.module_id) +} + +// optional bytes message = 2; +inline bool ModuleMessageRequest::has_message() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ModuleMessageRequest::set_has_message() { + _has_bits_[0] |= 0x00000002u; +} +inline void ModuleMessageRequest::clear_has_message() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ModuleMessageRequest::clear_message() { + if (message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + message_->clear(); + } + clear_has_message(); +} +inline const ::std::string& ModuleMessageRequest::message() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.ModuleMessageRequest.message) + return *message_; +} +inline void ModuleMessageRequest::set_message(const ::std::string& value) { + set_has_message(); + if (message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + message_ = new ::std::string; + } + message_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.ModuleMessageRequest.message) +} +inline void ModuleMessageRequest::set_message(const char* value) { + set_has_message(); + if (message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + message_ = new ::std::string; + } + message_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.ModuleMessageRequest.message) +} +inline void ModuleMessageRequest::set_message(const void* value, size_t size) { + set_has_message(); + if (message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + message_ = new ::std::string; + } + message_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.ModuleMessageRequest.message) +} +inline ::std::string* ModuleMessageRequest::mutable_message() { + set_has_message(); + if (message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + message_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.ModuleMessageRequest.message) + return message_; +} +inline ::std::string* ModuleMessageRequest::release_message() { + clear_has_message(); + if (message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = message_; + message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ModuleMessageRequest::set_allocated_message(::std::string* message) { + if (message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete message_; + } + if (message) { + set_has_message(); + message_ = message; + } else { + clear_has_message(); + message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.ModuleMessageRequest.message) +} + +// ------------------------------------------------------------------- + +// LogonRequest + +// optional string program = 1; +inline bool LogonRequest::has_program() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void LogonRequest::set_has_program() { + _has_bits_[0] |= 0x00000001u; +} +inline void LogonRequest::clear_has_program() { + _has_bits_[0] &= ~0x00000001u; +} +inline void LogonRequest::clear_program() { + if (program_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + program_->clear(); + } + clear_has_program(); +} +inline const ::std::string& LogonRequest::program() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.program) + return *program_; +} +inline void LogonRequest::set_program(const ::std::string& value) { + set_has_program(); + if (program_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + program_ = new ::std::string; + } + program_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.program) +} +inline void LogonRequest::set_program(const char* value) { + set_has_program(); + if (program_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + program_ = new ::std::string; + } + program_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonRequest.program) +} +inline void LogonRequest::set_program(const char* value, size_t size) { + set_has_program(); + if (program_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + program_ = new ::std::string; + } + program_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonRequest.program) +} +inline ::std::string* LogonRequest::mutable_program() { + set_has_program(); + if (program_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + program_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonRequest.program) + return program_; +} +inline ::std::string* LogonRequest::release_program() { + clear_has_program(); + if (program_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = program_; + program_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void LogonRequest::set_allocated_program(::std::string* program) { + if (program_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete program_; + } + if (program) { + set_has_program(); + program_ = program; + } else { + clear_has_program(); + program_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonRequest.program) +} + +// optional string platform = 2; +inline bool LogonRequest::has_platform() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void LogonRequest::set_has_platform() { + _has_bits_[0] |= 0x00000002u; +} +inline void LogonRequest::clear_has_platform() { + _has_bits_[0] &= ~0x00000002u; +} +inline void LogonRequest::clear_platform() { + if (platform_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + platform_->clear(); + } + clear_has_platform(); +} +inline const ::std::string& LogonRequest::platform() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.platform) + return *platform_; +} +inline void LogonRequest::set_platform(const ::std::string& value) { + set_has_platform(); + if (platform_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + platform_ = new ::std::string; + } + platform_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.platform) +} +inline void LogonRequest::set_platform(const char* value) { + set_has_platform(); + if (platform_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + platform_ = new ::std::string; + } + platform_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonRequest.platform) +} +inline void LogonRequest::set_platform(const char* value, size_t size) { + set_has_platform(); + if (platform_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + platform_ = new ::std::string; + } + platform_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonRequest.platform) +} +inline ::std::string* LogonRequest::mutable_platform() { + set_has_platform(); + if (platform_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + platform_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonRequest.platform) + return platform_; +} +inline ::std::string* LogonRequest::release_platform() { + clear_has_platform(); + if (platform_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = platform_; + platform_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void LogonRequest::set_allocated_platform(::std::string* platform) { + if (platform_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete platform_; + } + if (platform) { + set_has_platform(); + platform_ = platform; + } else { + clear_has_platform(); + platform_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonRequest.platform) +} + +// optional string locale = 3; +inline bool LogonRequest::has_locale() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void LogonRequest::set_has_locale() { + _has_bits_[0] |= 0x00000004u; +} +inline void LogonRequest::clear_has_locale() { + _has_bits_[0] &= ~0x00000004u; +} +inline void LogonRequest::clear_locale() { + if (locale_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + locale_->clear(); + } + clear_has_locale(); +} +inline const ::std::string& LogonRequest::locale() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.locale) + return *locale_; +} +inline void LogonRequest::set_locale(const ::std::string& value) { + set_has_locale(); + if (locale_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + locale_ = new ::std::string; + } + locale_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.locale) +} +inline void LogonRequest::set_locale(const char* value) { + set_has_locale(); + if (locale_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + locale_ = new ::std::string; + } + locale_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonRequest.locale) +} +inline void LogonRequest::set_locale(const char* value, size_t size) { + set_has_locale(); + if (locale_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + locale_ = new ::std::string; + } + locale_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonRequest.locale) +} +inline ::std::string* LogonRequest::mutable_locale() { + set_has_locale(); + if (locale_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + locale_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonRequest.locale) + return locale_; +} +inline ::std::string* LogonRequest::release_locale() { + clear_has_locale(); + if (locale_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = locale_; + locale_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void LogonRequest::set_allocated_locale(::std::string* locale) { + if (locale_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete locale_; + } + if (locale) { + set_has_locale(); + locale_ = locale; + } else { + clear_has_locale(); + locale_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonRequest.locale) +} + +// optional string email = 4; +inline bool LogonRequest::has_email() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void LogonRequest::set_has_email() { + _has_bits_[0] |= 0x00000008u; +} +inline void LogonRequest::clear_has_email() { + _has_bits_[0] &= ~0x00000008u; +} +inline void LogonRequest::clear_email() { + if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_->clear(); + } + clear_has_email(); +} +inline const ::std::string& LogonRequest::email() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.email) + return *email_; +} +inline void LogonRequest::set_email(const ::std::string& value) { + set_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_ = new ::std::string; + } + email_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.email) +} +inline void LogonRequest::set_email(const char* value) { + set_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_ = new ::std::string; + } + email_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonRequest.email) +} +inline void LogonRequest::set_email(const char* value, size_t size) { + set_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_ = new ::std::string; + } + email_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonRequest.email) +} +inline ::std::string* LogonRequest::mutable_email() { + set_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonRequest.email) + return email_; +} +inline ::std::string* LogonRequest::release_email() { + clear_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = email_; + email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void LogonRequest::set_allocated_email(::std::string* email) { + if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete email_; + } + if (email) { + set_has_email(); + email_ = email; + } else { + clear_has_email(); + email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonRequest.email) +} + +// optional string version = 5; +inline bool LogonRequest::has_version() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void LogonRequest::set_has_version() { + _has_bits_[0] |= 0x00000010u; +} +inline void LogonRequest::clear_has_version() { + _has_bits_[0] &= ~0x00000010u; +} +inline void LogonRequest::clear_version() { + if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + version_->clear(); + } + clear_has_version(); +} +inline const ::std::string& LogonRequest::version() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.version) + return *version_; +} +inline void LogonRequest::set_version(const ::std::string& value) { + set_has_version(); + if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + version_ = new ::std::string; + } + version_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.version) +} +inline void LogonRequest::set_version(const char* value) { + set_has_version(); + if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + version_ = new ::std::string; + } + version_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonRequest.version) +} +inline void LogonRequest::set_version(const char* value, size_t size) { + set_has_version(); + if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + version_ = new ::std::string; + } + version_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonRequest.version) +} +inline ::std::string* LogonRequest::mutable_version() { + set_has_version(); + if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + version_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonRequest.version) + return version_; +} +inline ::std::string* LogonRequest::release_version() { + clear_has_version(); + if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = version_; + version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void LogonRequest::set_allocated_version(::std::string* version) { + if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete version_; + } + if (version) { + set_has_version(); + version_ = version; + } else { + clear_has_version(); + version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonRequest.version) +} + +// optional int32 application_version = 6; +inline bool LogonRequest::has_application_version() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void LogonRequest::set_has_application_version() { + _has_bits_[0] |= 0x00000020u; +} +inline void LogonRequest::clear_has_application_version() { + _has_bits_[0] &= ~0x00000020u; +} +inline void LogonRequest::clear_application_version() { + application_version_ = 0; + clear_has_application_version(); +} +inline ::google::protobuf::int32 LogonRequest::application_version() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.application_version) + return application_version_; +} +inline void LogonRequest::set_application_version(::google::protobuf::int32 value) { + set_has_application_version(); + application_version_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.application_version) +} + +// optional bool public_computer = 7; +inline bool LogonRequest::has_public_computer() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void LogonRequest::set_has_public_computer() { + _has_bits_[0] |= 0x00000040u; +} +inline void LogonRequest::clear_has_public_computer() { + _has_bits_[0] &= ~0x00000040u; +} +inline void LogonRequest::clear_public_computer() { + public_computer_ = false; + clear_has_public_computer(); +} +inline bool LogonRequest::public_computer() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.public_computer) + return public_computer_; +} +inline void LogonRequest::set_public_computer(bool value) { + set_has_public_computer(); + public_computer_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.public_computer) +} + +// optional bytes sso_id = 8; +inline bool LogonRequest::has_sso_id() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void LogonRequest::set_has_sso_id() { + _has_bits_[0] |= 0x00000080u; +} +inline void LogonRequest::clear_has_sso_id() { + _has_bits_[0] &= ~0x00000080u; +} +inline void LogonRequest::clear_sso_id() { + if (sso_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sso_id_->clear(); + } + clear_has_sso_id(); +} +inline const ::std::string& LogonRequest::sso_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.sso_id) + return *sso_id_; +} +inline void LogonRequest::set_sso_id(const ::std::string& value) { + set_has_sso_id(); + if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sso_id_ = new ::std::string; + } + sso_id_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.sso_id) +} +inline void LogonRequest::set_sso_id(const char* value) { + set_has_sso_id(); + if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sso_id_ = new ::std::string; + } + sso_id_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonRequest.sso_id) +} +inline void LogonRequest::set_sso_id(const void* value, size_t size) { + set_has_sso_id(); + if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sso_id_ = new ::std::string; + } + sso_id_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonRequest.sso_id) +} +inline ::std::string* LogonRequest::mutable_sso_id() { + set_has_sso_id(); + if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sso_id_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonRequest.sso_id) + return sso_id_; +} +inline ::std::string* LogonRequest::release_sso_id() { + clear_has_sso_id(); + if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = sso_id_; + sso_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void LogonRequest::set_allocated_sso_id(::std::string* sso_id) { + if (sso_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete sso_id_; + } + if (sso_id) { + set_has_sso_id(); + sso_id_ = sso_id; + } else { + clear_has_sso_id(); + sso_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonRequest.sso_id) +} + +// optional bool disconnect_on_cookie_fail = 9 [default = false]; +inline bool LogonRequest::has_disconnect_on_cookie_fail() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void LogonRequest::set_has_disconnect_on_cookie_fail() { + _has_bits_[0] |= 0x00000100u; +} +inline void LogonRequest::clear_has_disconnect_on_cookie_fail() { + _has_bits_[0] &= ~0x00000100u; +} +inline void LogonRequest::clear_disconnect_on_cookie_fail() { + disconnect_on_cookie_fail_ = false; + clear_has_disconnect_on_cookie_fail(); +} +inline bool LogonRequest::disconnect_on_cookie_fail() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.disconnect_on_cookie_fail) + return disconnect_on_cookie_fail_; +} +inline void LogonRequest::set_disconnect_on_cookie_fail(bool value) { + set_has_disconnect_on_cookie_fail(); + disconnect_on_cookie_fail_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.disconnect_on_cookie_fail) +} + +// optional bool allow_logon_queue_notifications = 10 [default = false]; +inline bool LogonRequest::has_allow_logon_queue_notifications() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +inline void LogonRequest::set_has_allow_logon_queue_notifications() { + _has_bits_[0] |= 0x00000200u; +} +inline void LogonRequest::clear_has_allow_logon_queue_notifications() { + _has_bits_[0] &= ~0x00000200u; +} +inline void LogonRequest::clear_allow_logon_queue_notifications() { + allow_logon_queue_notifications_ = false; + clear_has_allow_logon_queue_notifications(); +} +inline bool LogonRequest::allow_logon_queue_notifications() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.allow_logon_queue_notifications) + return allow_logon_queue_notifications_; +} +inline void LogonRequest::set_allow_logon_queue_notifications(bool value) { + set_has_allow_logon_queue_notifications(); + allow_logon_queue_notifications_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.allow_logon_queue_notifications) +} + +// optional bool web_client_verification = 11 [default = false]; +inline bool LogonRequest::has_web_client_verification() const { + return (_has_bits_[0] & 0x00000400u) != 0; +} +inline void LogonRequest::set_has_web_client_verification() { + _has_bits_[0] |= 0x00000400u; +} +inline void LogonRequest::clear_has_web_client_verification() { + _has_bits_[0] &= ~0x00000400u; +} +inline void LogonRequest::clear_web_client_verification() { + web_client_verification_ = false; + clear_has_web_client_verification(); +} +inline bool LogonRequest::web_client_verification() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.web_client_verification) + return web_client_verification_; +} +inline void LogonRequest::set_web_client_verification(bool value) { + set_has_web_client_verification(); + web_client_verification_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.web_client_verification) +} + +// optional bytes cached_web_credentials = 12; +inline bool LogonRequest::has_cached_web_credentials() const { + return (_has_bits_[0] & 0x00000800u) != 0; +} +inline void LogonRequest::set_has_cached_web_credentials() { + _has_bits_[0] |= 0x00000800u; +} +inline void LogonRequest::clear_has_cached_web_credentials() { + _has_bits_[0] &= ~0x00000800u; +} +inline void LogonRequest::clear_cached_web_credentials() { + if (cached_web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + cached_web_credentials_->clear(); + } + clear_has_cached_web_credentials(); +} +inline const ::std::string& LogonRequest::cached_web_credentials() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.cached_web_credentials) + return *cached_web_credentials_; +} +inline void LogonRequest::set_cached_web_credentials(const ::std::string& value) { + set_has_cached_web_credentials(); + if (cached_web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + cached_web_credentials_ = new ::std::string; + } + cached_web_credentials_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.cached_web_credentials) +} +inline void LogonRequest::set_cached_web_credentials(const char* value) { + set_has_cached_web_credentials(); + if (cached_web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + cached_web_credentials_ = new ::std::string; + } + cached_web_credentials_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonRequest.cached_web_credentials) +} +inline void LogonRequest::set_cached_web_credentials(const void* value, size_t size) { + set_has_cached_web_credentials(); + if (cached_web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + cached_web_credentials_ = new ::std::string; + } + cached_web_credentials_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonRequest.cached_web_credentials) +} +inline ::std::string* LogonRequest::mutable_cached_web_credentials() { + set_has_cached_web_credentials(); + if (cached_web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + cached_web_credentials_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonRequest.cached_web_credentials) + return cached_web_credentials_; +} +inline ::std::string* LogonRequest::release_cached_web_credentials() { + clear_has_cached_web_credentials(); + if (cached_web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = cached_web_credentials_; + cached_web_credentials_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void LogonRequest::set_allocated_cached_web_credentials(::std::string* cached_web_credentials) { + if (cached_web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete cached_web_credentials_; + } + if (cached_web_credentials) { + set_has_cached_web_credentials(); + cached_web_credentials_ = cached_web_credentials; + } else { + clear_has_cached_web_credentials(); + cached_web_credentials_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonRequest.cached_web_credentials) +} + +// optional bool enable_cookie = 13 [default = true]; +inline bool LogonRequest::has_enable_cookie() const { + return (_has_bits_[0] & 0x00001000u) != 0; +} +inline void LogonRequest::set_has_enable_cookie() { + _has_bits_[0] |= 0x00001000u; +} +inline void LogonRequest::clear_has_enable_cookie() { + _has_bits_[0] &= ~0x00001000u; +} +inline void LogonRequest::clear_enable_cookie() { + enable_cookie_ = true; + clear_has_enable_cookie(); +} +inline bool LogonRequest::enable_cookie() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.enable_cookie) + return enable_cookie_; +} +inline void LogonRequest::set_enable_cookie(bool value) { + set_has_enable_cookie(); + enable_cookie_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.enable_cookie) +} + +// optional string user_agent = 14; +inline bool LogonRequest::has_user_agent() const { + return (_has_bits_[0] & 0x00002000u) != 0; +} +inline void LogonRequest::set_has_user_agent() { + _has_bits_[0] |= 0x00002000u; +} +inline void LogonRequest::clear_has_user_agent() { + _has_bits_[0] &= ~0x00002000u; +} +inline void LogonRequest::clear_user_agent() { + if (user_agent_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + user_agent_->clear(); + } + clear_has_user_agent(); +} +inline const ::std::string& LogonRequest::user_agent() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.user_agent) + return *user_agent_; +} +inline void LogonRequest::set_user_agent(const ::std::string& value) { + set_has_user_agent(); + if (user_agent_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + user_agent_ = new ::std::string; + } + user_agent_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.user_agent) +} +inline void LogonRequest::set_user_agent(const char* value) { + set_has_user_agent(); + if (user_agent_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + user_agent_ = new ::std::string; + } + user_agent_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonRequest.user_agent) +} +inline void LogonRequest::set_user_agent(const char* value, size_t size) { + set_has_user_agent(); + if (user_agent_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + user_agent_ = new ::std::string; + } + user_agent_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonRequest.user_agent) +} +inline ::std::string* LogonRequest::mutable_user_agent() { + set_has_user_agent(); + if (user_agent_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + user_agent_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonRequest.user_agent) + return user_agent_; +} +inline ::std::string* LogonRequest::release_user_agent() { + clear_has_user_agent(); + if (user_agent_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = user_agent_; + user_agent_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void LogonRequest::set_allocated_user_agent(::std::string* user_agent) { + if (user_agent_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete user_agent_; + } + if (user_agent) { + set_has_user_agent(); + user_agent_ = user_agent; + } else { + clear_has_user_agent(); + user_agent_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonRequest.user_agent) +} + +// ------------------------------------------------------------------- + +// LogonResult + +// required uint32 error_code = 1; +inline bool LogonResult::has_error_code() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void LogonResult::set_has_error_code() { + _has_bits_[0] |= 0x00000001u; +} +inline void LogonResult::clear_has_error_code() { + _has_bits_[0] &= ~0x00000001u; +} +inline void LogonResult::clear_error_code() { + error_code_ = 0u; + clear_has_error_code(); +} +inline ::google::protobuf::uint32 LogonResult::error_code() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonResult.error_code) + return error_code_; +} +inline void LogonResult::set_error_code(::google::protobuf::uint32 value) { + set_has_error_code(); + error_code_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonResult.error_code) +} + +// optional .bgs.protocol.EntityId account_id = 2; +inline bool LogonResult::has_account_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void LogonResult::set_has_account_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void LogonResult::clear_has_account_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void LogonResult::clear_account_id() { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_account_id(); +} +inline const ::bgs::protocol::EntityId& LogonResult::account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonResult.account_id) + return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_; +} +inline ::bgs::protocol::EntityId* LogonResult::mutable_account_id() { + set_has_account_id(); + if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonResult.account_id) + return account_id_; +} +inline ::bgs::protocol::EntityId* LogonResult::release_account_id() { + clear_has_account_id(); + ::bgs::protocol::EntityId* temp = account_id_; + account_id_ = NULL; + return temp; +} +inline void LogonResult::set_allocated_account_id(::bgs::protocol::EntityId* account_id) { + delete account_id_; + account_id_ = account_id; + if (account_id) { + set_has_account_id(); + } else { + clear_has_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonResult.account_id) +} + +// repeated .bgs.protocol.EntityId game_account_id = 3; +inline int LogonResult::game_account_id_size() const { + return game_account_id_.size(); +} +inline void LogonResult::clear_game_account_id() { + game_account_id_.Clear(); +} +inline const ::bgs::protocol::EntityId& LogonResult::game_account_id(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonResult.game_account_id) + return game_account_id_.Get(index); +} +inline ::bgs::protocol::EntityId* LogonResult::mutable_game_account_id(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonResult.game_account_id) + return game_account_id_.Mutable(index); +} +inline ::bgs::protocol::EntityId* LogonResult::add_game_account_id() { + // @@protoc_insertion_point(field_add:bgs.protocol.authentication.v1.LogonResult.game_account_id) + return game_account_id_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId >& +LogonResult::game_account_id() const { + // @@protoc_insertion_point(field_list:bgs.protocol.authentication.v1.LogonResult.game_account_id) + return game_account_id_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId >* +LogonResult::mutable_game_account_id() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.authentication.v1.LogonResult.game_account_id) + return &game_account_id_; +} + +// optional string email = 4; +inline bool LogonResult::has_email() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void LogonResult::set_has_email() { + _has_bits_[0] |= 0x00000008u; +} +inline void LogonResult::clear_has_email() { + _has_bits_[0] &= ~0x00000008u; +} +inline void LogonResult::clear_email() { + if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_->clear(); + } + clear_has_email(); +} +inline const ::std::string& LogonResult::email() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonResult.email) + return *email_; +} +inline void LogonResult::set_email(const ::std::string& value) { + set_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_ = new ::std::string; + } + email_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonResult.email) +} +inline void LogonResult::set_email(const char* value) { + set_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_ = new ::std::string; + } + email_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonResult.email) +} +inline void LogonResult::set_email(const char* value, size_t size) { + set_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_ = new ::std::string; + } + email_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonResult.email) +} +inline ::std::string* LogonResult::mutable_email() { + set_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonResult.email) + return email_; +} +inline ::std::string* LogonResult::release_email() { + clear_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = email_; + email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void LogonResult::set_allocated_email(::std::string* email) { + if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete email_; + } + if (email) { + set_has_email(); + email_ = email; + } else { + clear_has_email(); + email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonResult.email) +} + +// repeated uint32 available_region = 5; +inline int LogonResult::available_region_size() const { + return available_region_.size(); +} +inline void LogonResult::clear_available_region() { + available_region_.Clear(); +} +inline ::google::protobuf::uint32 LogonResult::available_region(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonResult.available_region) + return available_region_.Get(index); +} +inline void LogonResult::set_available_region(int index, ::google::protobuf::uint32 value) { + available_region_.Set(index, value); + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonResult.available_region) +} +inline void LogonResult::add_available_region(::google::protobuf::uint32 value) { + available_region_.Add(value); + // @@protoc_insertion_point(field_add:bgs.protocol.authentication.v1.LogonResult.available_region) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +LogonResult::available_region() const { + // @@protoc_insertion_point(field_list:bgs.protocol.authentication.v1.LogonResult.available_region) + return available_region_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +LogonResult::mutable_available_region() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.authentication.v1.LogonResult.available_region) + return &available_region_; +} + +// optional uint32 connected_region = 6; +inline bool LogonResult::has_connected_region() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void LogonResult::set_has_connected_region() { + _has_bits_[0] |= 0x00000020u; +} +inline void LogonResult::clear_has_connected_region() { + _has_bits_[0] &= ~0x00000020u; +} +inline void LogonResult::clear_connected_region() { + connected_region_ = 0u; + clear_has_connected_region(); +} +inline ::google::protobuf::uint32 LogonResult::connected_region() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonResult.connected_region) + return connected_region_; +} +inline void LogonResult::set_connected_region(::google::protobuf::uint32 value) { + set_has_connected_region(); + connected_region_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonResult.connected_region) +} + +// optional string battle_tag = 7; +inline bool LogonResult::has_battle_tag() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void LogonResult::set_has_battle_tag() { + _has_bits_[0] |= 0x00000040u; +} +inline void LogonResult::clear_has_battle_tag() { + _has_bits_[0] &= ~0x00000040u; +} +inline void LogonResult::clear_battle_tag() { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_->clear(); + } + clear_has_battle_tag(); +} +inline const ::std::string& LogonResult::battle_tag() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonResult.battle_tag) + return *battle_tag_; +} +inline void LogonResult::set_battle_tag(const ::std::string& value) { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + battle_tag_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonResult.battle_tag) +} +inline void LogonResult::set_battle_tag(const char* value) { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + battle_tag_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonResult.battle_tag) +} +inline void LogonResult::set_battle_tag(const char* value, size_t size) { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + battle_tag_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonResult.battle_tag) +} +inline ::std::string* LogonResult::mutable_battle_tag() { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonResult.battle_tag) + return battle_tag_; +} +inline ::std::string* LogonResult::release_battle_tag() { + clear_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = battle_tag_; + battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void LogonResult::set_allocated_battle_tag(::std::string* battle_tag) { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete battle_tag_; + } + if (battle_tag) { + set_has_battle_tag(); + battle_tag_ = battle_tag; + } else { + clear_has_battle_tag(); + battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonResult.battle_tag) +} + +// optional string geoip_country = 8; +inline bool LogonResult::has_geoip_country() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void LogonResult::set_has_geoip_country() { + _has_bits_[0] |= 0x00000080u; +} +inline void LogonResult::clear_has_geoip_country() { + _has_bits_[0] &= ~0x00000080u; +} +inline void LogonResult::clear_geoip_country() { + if (geoip_country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + geoip_country_->clear(); + } + clear_has_geoip_country(); +} +inline const ::std::string& LogonResult::geoip_country() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonResult.geoip_country) + return *geoip_country_; +} +inline void LogonResult::set_geoip_country(const ::std::string& value) { + set_has_geoip_country(); + if (geoip_country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + geoip_country_ = new ::std::string; + } + geoip_country_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonResult.geoip_country) +} +inline void LogonResult::set_geoip_country(const char* value) { + set_has_geoip_country(); + if (geoip_country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + geoip_country_ = new ::std::string; + } + geoip_country_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonResult.geoip_country) +} +inline void LogonResult::set_geoip_country(const char* value, size_t size) { + set_has_geoip_country(); + if (geoip_country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + geoip_country_ = new ::std::string; + } + geoip_country_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonResult.geoip_country) +} +inline ::std::string* LogonResult::mutable_geoip_country() { + set_has_geoip_country(); + if (geoip_country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + geoip_country_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonResult.geoip_country) + return geoip_country_; +} +inline ::std::string* LogonResult::release_geoip_country() { + clear_has_geoip_country(); + if (geoip_country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = geoip_country_; + geoip_country_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void LogonResult::set_allocated_geoip_country(::std::string* geoip_country) { + if (geoip_country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete geoip_country_; + } + if (geoip_country) { + set_has_geoip_country(); + geoip_country_ = geoip_country; + } else { + clear_has_geoip_country(); + geoip_country_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonResult.geoip_country) +} + +// optional bytes session_key = 9; +inline bool LogonResult::has_session_key() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void LogonResult::set_has_session_key() { + _has_bits_[0] |= 0x00000100u; +} +inline void LogonResult::clear_has_session_key() { + _has_bits_[0] &= ~0x00000100u; +} +inline void LogonResult::clear_session_key() { + if (session_key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + session_key_->clear(); + } + clear_has_session_key(); +} +inline const ::std::string& LogonResult::session_key() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonResult.session_key) + return *session_key_; +} +inline void LogonResult::set_session_key(const ::std::string& value) { + set_has_session_key(); + if (session_key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + session_key_ = new ::std::string; + } + session_key_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonResult.session_key) +} +inline void LogonResult::set_session_key(const char* value) { + set_has_session_key(); + if (session_key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + session_key_ = new ::std::string; + } + session_key_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonResult.session_key) +} +inline void LogonResult::set_session_key(const void* value, size_t size) { + set_has_session_key(); + if (session_key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + session_key_ = new ::std::string; + } + session_key_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonResult.session_key) +} +inline ::std::string* LogonResult::mutable_session_key() { + set_has_session_key(); + if (session_key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + session_key_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonResult.session_key) + return session_key_; +} +inline ::std::string* LogonResult::release_session_key() { + clear_has_session_key(); + if (session_key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = session_key_; + session_key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void LogonResult::set_allocated_session_key(::std::string* session_key) { + if (session_key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete session_key_; + } + if (session_key) { + set_has_session_key(); + session_key_ = session_key; + } else { + clear_has_session_key(); + session_key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonResult.session_key) +} + +// optional bool restricted_mode = 10; +inline bool LogonResult::has_restricted_mode() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +inline void LogonResult::set_has_restricted_mode() { + _has_bits_[0] |= 0x00000200u; +} +inline void LogonResult::clear_has_restricted_mode() { + _has_bits_[0] &= ~0x00000200u; +} +inline void LogonResult::clear_restricted_mode() { + restricted_mode_ = false; + clear_has_restricted_mode(); +} +inline bool LogonResult::restricted_mode() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonResult.restricted_mode) + return restricted_mode_; +} +inline void LogonResult::set_restricted_mode(bool value) { + set_has_restricted_mode(); + restricted_mode_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonResult.restricted_mode) +} + +// ------------------------------------------------------------------- + +// GenerateSSOTokenRequest + +// optional fixed32 program = 1; +inline bool GenerateSSOTokenRequest::has_program() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GenerateSSOTokenRequest::set_has_program() { + _has_bits_[0] |= 0x00000001u; +} +inline void GenerateSSOTokenRequest::clear_has_program() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GenerateSSOTokenRequest::clear_program() { + program_ = 0u; + clear_has_program(); +} +inline ::google::protobuf::uint32 GenerateSSOTokenRequest::program() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.GenerateSSOTokenRequest.program) + return program_; +} +inline void GenerateSSOTokenRequest::set_program(::google::protobuf::uint32 value) { + set_has_program(); + program_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.GenerateSSOTokenRequest.program) +} + +// ------------------------------------------------------------------- + +// GenerateSSOTokenResponse + +// optional bytes sso_id = 1; +inline bool GenerateSSOTokenResponse::has_sso_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GenerateSSOTokenResponse::set_has_sso_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void GenerateSSOTokenResponse::clear_has_sso_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GenerateSSOTokenResponse::clear_sso_id() { + if (sso_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sso_id_->clear(); + } + clear_has_sso_id(); +} +inline const ::std::string& GenerateSSOTokenResponse::sso_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.GenerateSSOTokenResponse.sso_id) + return *sso_id_; +} +inline void GenerateSSOTokenResponse::set_sso_id(const ::std::string& value) { + set_has_sso_id(); + if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sso_id_ = new ::std::string; + } + sso_id_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.GenerateSSOTokenResponse.sso_id) +} +inline void GenerateSSOTokenResponse::set_sso_id(const char* value) { + set_has_sso_id(); + if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sso_id_ = new ::std::string; + } + sso_id_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.GenerateSSOTokenResponse.sso_id) +} +inline void GenerateSSOTokenResponse::set_sso_id(const void* value, size_t size) { + set_has_sso_id(); + if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sso_id_ = new ::std::string; + } + sso_id_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.GenerateSSOTokenResponse.sso_id) +} +inline ::std::string* GenerateSSOTokenResponse::mutable_sso_id() { + set_has_sso_id(); + if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sso_id_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.GenerateSSOTokenResponse.sso_id) + return sso_id_; +} +inline ::std::string* GenerateSSOTokenResponse::release_sso_id() { + clear_has_sso_id(); + if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = sso_id_; + sso_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void GenerateSSOTokenResponse::set_allocated_sso_id(::std::string* sso_id) { + if (sso_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete sso_id_; + } + if (sso_id) { + set_has_sso_id(); + sso_id_ = sso_id; + } else { + clear_has_sso_id(); + sso_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.GenerateSSOTokenResponse.sso_id) +} + +// optional bytes sso_secret = 2; +inline bool GenerateSSOTokenResponse::has_sso_secret() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GenerateSSOTokenResponse::set_has_sso_secret() { + _has_bits_[0] |= 0x00000002u; +} +inline void GenerateSSOTokenResponse::clear_has_sso_secret() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GenerateSSOTokenResponse::clear_sso_secret() { + if (sso_secret_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sso_secret_->clear(); + } + clear_has_sso_secret(); +} +inline const ::std::string& GenerateSSOTokenResponse::sso_secret() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.GenerateSSOTokenResponse.sso_secret) + return *sso_secret_; +} +inline void GenerateSSOTokenResponse::set_sso_secret(const ::std::string& value) { + set_has_sso_secret(); + if (sso_secret_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sso_secret_ = new ::std::string; + } + sso_secret_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.GenerateSSOTokenResponse.sso_secret) +} +inline void GenerateSSOTokenResponse::set_sso_secret(const char* value) { + set_has_sso_secret(); + if (sso_secret_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sso_secret_ = new ::std::string; + } + sso_secret_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.GenerateSSOTokenResponse.sso_secret) +} +inline void GenerateSSOTokenResponse::set_sso_secret(const void* value, size_t size) { + set_has_sso_secret(); + if (sso_secret_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sso_secret_ = new ::std::string; + } + sso_secret_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.GenerateSSOTokenResponse.sso_secret) +} +inline ::std::string* GenerateSSOTokenResponse::mutable_sso_secret() { + set_has_sso_secret(); + if (sso_secret_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sso_secret_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.GenerateSSOTokenResponse.sso_secret) + return sso_secret_; +} +inline ::std::string* GenerateSSOTokenResponse::release_sso_secret() { + clear_has_sso_secret(); + if (sso_secret_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = sso_secret_; + sso_secret_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void GenerateSSOTokenResponse::set_allocated_sso_secret(::std::string* sso_secret) { + if (sso_secret_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete sso_secret_; + } + if (sso_secret) { + set_has_sso_secret(); + sso_secret_ = sso_secret; + } else { + clear_has_sso_secret(); + sso_secret_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.GenerateSSOTokenResponse.sso_secret) +} + +// ------------------------------------------------------------------- + +// LogonUpdateRequest + +// required uint32 error_code = 1; +inline bool LogonUpdateRequest::has_error_code() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void LogonUpdateRequest::set_has_error_code() { + _has_bits_[0] |= 0x00000001u; +} +inline void LogonUpdateRequest::clear_has_error_code() { + _has_bits_[0] &= ~0x00000001u; +} +inline void LogonUpdateRequest::clear_error_code() { + error_code_ = 0u; + clear_has_error_code(); +} +inline ::google::protobuf::uint32 LogonUpdateRequest::error_code() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonUpdateRequest.error_code) + return error_code_; +} +inline void LogonUpdateRequest::set_error_code(::google::protobuf::uint32 value) { + set_has_error_code(); + error_code_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonUpdateRequest.error_code) +} + +// ------------------------------------------------------------------- + +// LogonQueueUpdateRequest + +// required uint32 position = 1; +inline bool LogonQueueUpdateRequest::has_position() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void LogonQueueUpdateRequest::set_has_position() { + _has_bits_[0] |= 0x00000001u; +} +inline void LogonQueueUpdateRequest::clear_has_position() { + _has_bits_[0] &= ~0x00000001u; +} +inline void LogonQueueUpdateRequest::clear_position() { + position_ = 0u; + clear_has_position(); +} +inline ::google::protobuf::uint32 LogonQueueUpdateRequest::position() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonQueueUpdateRequest.position) + return position_; +} +inline void LogonQueueUpdateRequest::set_position(::google::protobuf::uint32 value) { + set_has_position(); + position_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonQueueUpdateRequest.position) +} + +// required uint64 estimated_time = 2; +inline bool LogonQueueUpdateRequest::has_estimated_time() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void LogonQueueUpdateRequest::set_has_estimated_time() { + _has_bits_[0] |= 0x00000002u; +} +inline void LogonQueueUpdateRequest::clear_has_estimated_time() { + _has_bits_[0] &= ~0x00000002u; +} +inline void LogonQueueUpdateRequest::clear_estimated_time() { + estimated_time_ = GOOGLE_ULONGLONG(0); + clear_has_estimated_time(); +} +inline ::google::protobuf::uint64 LogonQueueUpdateRequest::estimated_time() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonQueueUpdateRequest.estimated_time) + return estimated_time_; +} +inline void LogonQueueUpdateRequest::set_estimated_time(::google::protobuf::uint64 value) { + set_has_estimated_time(); + estimated_time_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonQueueUpdateRequest.estimated_time) +} + +// required uint64 eta_deviation_in_sec = 3; +inline bool LogonQueueUpdateRequest::has_eta_deviation_in_sec() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void LogonQueueUpdateRequest::set_has_eta_deviation_in_sec() { + _has_bits_[0] |= 0x00000004u; +} +inline void LogonQueueUpdateRequest::clear_has_eta_deviation_in_sec() { + _has_bits_[0] &= ~0x00000004u; +} +inline void LogonQueueUpdateRequest::clear_eta_deviation_in_sec() { + eta_deviation_in_sec_ = GOOGLE_ULONGLONG(0); + clear_has_eta_deviation_in_sec(); +} +inline ::google::protobuf::uint64 LogonQueueUpdateRequest::eta_deviation_in_sec() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonQueueUpdateRequest.eta_deviation_in_sec) + return eta_deviation_in_sec_; +} +inline void LogonQueueUpdateRequest::set_eta_deviation_in_sec(::google::protobuf::uint64 value) { + set_has_eta_deviation_in_sec(); + eta_deviation_in_sec_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonQueueUpdateRequest.eta_deviation_in_sec) +} + +// ------------------------------------------------------------------- + +// AccountSettingsNotification + +// repeated .bgs.protocol.account.v1.AccountLicense licenses = 1; +inline int AccountSettingsNotification::licenses_size() const { + return licenses_.size(); +} +inline void AccountSettingsNotification::clear_licenses() { + licenses_.Clear(); +} +inline const ::bgs::protocol::account::v1::AccountLicense& AccountSettingsNotification::licenses(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.AccountSettingsNotification.licenses) + return licenses_.Get(index); +} +inline ::bgs::protocol::account::v1::AccountLicense* AccountSettingsNotification::mutable_licenses(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.AccountSettingsNotification.licenses) + return licenses_.Mutable(index); +} +inline ::bgs::protocol::account::v1::AccountLicense* AccountSettingsNotification::add_licenses() { + // @@protoc_insertion_point(field_add:bgs.protocol.authentication.v1.AccountSettingsNotification.licenses) + return licenses_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >& +AccountSettingsNotification::licenses() const { + // @@protoc_insertion_point(field_list:bgs.protocol.authentication.v1.AccountSettingsNotification.licenses) + return licenses_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >* +AccountSettingsNotification::mutable_licenses() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.authentication.v1.AccountSettingsNotification.licenses) + return &licenses_; +} + +// optional bool is_using_rid = 2; +inline bool AccountSettingsNotification::has_is_using_rid() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void AccountSettingsNotification::set_has_is_using_rid() { + _has_bits_[0] |= 0x00000002u; +} +inline void AccountSettingsNotification::clear_has_is_using_rid() { + _has_bits_[0] &= ~0x00000002u; +} +inline void AccountSettingsNotification::clear_is_using_rid() { + is_using_rid_ = false; + clear_has_is_using_rid(); +} +inline bool AccountSettingsNotification::is_using_rid() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.AccountSettingsNotification.is_using_rid) + return is_using_rid_; +} +inline void AccountSettingsNotification::set_is_using_rid(bool value) { + set_has_is_using_rid(); + is_using_rid_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.AccountSettingsNotification.is_using_rid) +} + +// optional bool is_playing_from_igr = 3; +inline bool AccountSettingsNotification::has_is_playing_from_igr() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void AccountSettingsNotification::set_has_is_playing_from_igr() { + _has_bits_[0] |= 0x00000004u; +} +inline void AccountSettingsNotification::clear_has_is_playing_from_igr() { + _has_bits_[0] &= ~0x00000004u; +} +inline void AccountSettingsNotification::clear_is_playing_from_igr() { + is_playing_from_igr_ = false; + clear_has_is_playing_from_igr(); +} +inline bool AccountSettingsNotification::is_playing_from_igr() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.AccountSettingsNotification.is_playing_from_igr) + return is_playing_from_igr_; +} +inline void AccountSettingsNotification::set_is_playing_from_igr(bool value) { + set_has_is_playing_from_igr(); + is_playing_from_igr_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.AccountSettingsNotification.is_playing_from_igr) +} + +// optional bool can_receive_voice = 4; +inline bool AccountSettingsNotification::has_can_receive_voice() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void AccountSettingsNotification::set_has_can_receive_voice() { + _has_bits_[0] |= 0x00000008u; +} +inline void AccountSettingsNotification::clear_has_can_receive_voice() { + _has_bits_[0] &= ~0x00000008u; +} +inline void AccountSettingsNotification::clear_can_receive_voice() { + can_receive_voice_ = false; + clear_has_can_receive_voice(); +} +inline bool AccountSettingsNotification::can_receive_voice() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.AccountSettingsNotification.can_receive_voice) + return can_receive_voice_; +} +inline void AccountSettingsNotification::set_can_receive_voice(bool value) { + set_has_can_receive_voice(); + can_receive_voice_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.AccountSettingsNotification.can_receive_voice) +} + +// optional bool can_send_voice = 5; +inline bool AccountSettingsNotification::has_can_send_voice() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void AccountSettingsNotification::set_has_can_send_voice() { + _has_bits_[0] |= 0x00000010u; +} +inline void AccountSettingsNotification::clear_has_can_send_voice() { + _has_bits_[0] &= ~0x00000010u; +} +inline void AccountSettingsNotification::clear_can_send_voice() { + can_send_voice_ = false; + clear_has_can_send_voice(); +} +inline bool AccountSettingsNotification::can_send_voice() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.AccountSettingsNotification.can_send_voice) + return can_send_voice_; +} +inline void AccountSettingsNotification::set_can_send_voice(bool value) { + set_has_can_send_voice(); + can_send_voice_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.AccountSettingsNotification.can_send_voice) +} + +// ------------------------------------------------------------------- + +// ServerStateChangeRequest + +// required uint32 state = 1; +inline bool ServerStateChangeRequest::has_state() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ServerStateChangeRequest::set_has_state() { + _has_bits_[0] |= 0x00000001u; +} +inline void ServerStateChangeRequest::clear_has_state() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ServerStateChangeRequest::clear_state() { + state_ = 0u; + clear_has_state(); +} +inline ::google::protobuf::uint32 ServerStateChangeRequest::state() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.ServerStateChangeRequest.state) + return state_; +} +inline void ServerStateChangeRequest::set_state(::google::protobuf::uint32 value) { + set_has_state(); + state_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.ServerStateChangeRequest.state) +} + +// required uint64 event_time = 2; +inline bool ServerStateChangeRequest::has_event_time() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ServerStateChangeRequest::set_has_event_time() { + _has_bits_[0] |= 0x00000002u; +} +inline void ServerStateChangeRequest::clear_has_event_time() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ServerStateChangeRequest::clear_event_time() { + event_time_ = GOOGLE_ULONGLONG(0); + clear_has_event_time(); +} +inline ::google::protobuf::uint64 ServerStateChangeRequest::event_time() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.ServerStateChangeRequest.event_time) + return event_time_; +} +inline void ServerStateChangeRequest::set_event_time(::google::protobuf::uint64 value) { + set_has_event_time(); + event_time_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.ServerStateChangeRequest.event_time) +} + +// ------------------------------------------------------------------- + +// VersionInfo + +// optional uint32 number = 1; +inline bool VersionInfo::has_number() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void VersionInfo::set_has_number() { + _has_bits_[0] |= 0x00000001u; +} +inline void VersionInfo::clear_has_number() { + _has_bits_[0] &= ~0x00000001u; +} +inline void VersionInfo::clear_number() { + number_ = 0u; + clear_has_number(); +} +inline ::google::protobuf::uint32 VersionInfo::number() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.VersionInfo.number) + return number_; +} +inline void VersionInfo::set_number(::google::protobuf::uint32 value) { + set_has_number(); + number_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.VersionInfo.number) +} + +// optional string patch = 2; +inline bool VersionInfo::has_patch() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void VersionInfo::set_has_patch() { + _has_bits_[0] |= 0x00000002u; +} +inline void VersionInfo::clear_has_patch() { + _has_bits_[0] &= ~0x00000002u; +} +inline void VersionInfo::clear_patch() { + if (patch_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + patch_->clear(); + } + clear_has_patch(); +} +inline const ::std::string& VersionInfo::patch() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.VersionInfo.patch) + return *patch_; +} +inline void VersionInfo::set_patch(const ::std::string& value) { + set_has_patch(); + if (patch_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + patch_ = new ::std::string; + } + patch_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.VersionInfo.patch) +} +inline void VersionInfo::set_patch(const char* value) { + set_has_patch(); + if (patch_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + patch_ = new ::std::string; + } + patch_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.VersionInfo.patch) +} +inline void VersionInfo::set_patch(const char* value, size_t size) { + set_has_patch(); + if (patch_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + patch_ = new ::std::string; + } + patch_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.VersionInfo.patch) +} +inline ::std::string* VersionInfo::mutable_patch() { + set_has_patch(); + if (patch_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + patch_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.VersionInfo.patch) + return patch_; +} +inline ::std::string* VersionInfo::release_patch() { + clear_has_patch(); + if (patch_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = patch_; + patch_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void VersionInfo::set_allocated_patch(::std::string* patch) { + if (patch_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete patch_; + } + if (patch) { + set_has_patch(); + patch_ = patch; + } else { + clear_has_patch(); + patch_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.VersionInfo.patch) +} + +// optional bool is_optional = 3; +inline bool VersionInfo::has_is_optional() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void VersionInfo::set_has_is_optional() { + _has_bits_[0] |= 0x00000004u; +} +inline void VersionInfo::clear_has_is_optional() { + _has_bits_[0] &= ~0x00000004u; +} +inline void VersionInfo::clear_is_optional() { + is_optional_ = false; + clear_has_is_optional(); +} +inline bool VersionInfo::is_optional() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.VersionInfo.is_optional) + return is_optional_; +} +inline void VersionInfo::set_is_optional(bool value) { + set_has_is_optional(); + is_optional_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.VersionInfo.is_optional) +} + +// optional uint64 kick_time = 4; +inline bool VersionInfo::has_kick_time() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void VersionInfo::set_has_kick_time() { + _has_bits_[0] |= 0x00000008u; +} +inline void VersionInfo::clear_has_kick_time() { + _has_bits_[0] &= ~0x00000008u; +} +inline void VersionInfo::clear_kick_time() { + kick_time_ = GOOGLE_ULONGLONG(0); + clear_has_kick_time(); +} +inline ::google::protobuf::uint64 VersionInfo::kick_time() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.VersionInfo.kick_time) + return kick_time_; +} +inline void VersionInfo::set_kick_time(::google::protobuf::uint64 value) { + set_has_kick_time(); + kick_time_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.VersionInfo.kick_time) +} + +// ------------------------------------------------------------------- + +// VersionInfoNotification + +// optional .bgs.protocol.authentication.v1.VersionInfo version_info = 1; +inline bool VersionInfoNotification::has_version_info() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void VersionInfoNotification::set_has_version_info() { + _has_bits_[0] |= 0x00000001u; +} +inline void VersionInfoNotification::clear_has_version_info() { + _has_bits_[0] &= ~0x00000001u; +} +inline void VersionInfoNotification::clear_version_info() { + if (version_info_ != NULL) version_info_->::bgs::protocol::authentication::v1::VersionInfo::Clear(); + clear_has_version_info(); +} +inline const ::bgs::protocol::authentication::v1::VersionInfo& VersionInfoNotification::version_info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.VersionInfoNotification.version_info) + return version_info_ != NULL ? *version_info_ : *default_instance_->version_info_; +} +inline ::bgs::protocol::authentication::v1::VersionInfo* VersionInfoNotification::mutable_version_info() { + set_has_version_info(); + if (version_info_ == NULL) version_info_ = new ::bgs::protocol::authentication::v1::VersionInfo; + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.VersionInfoNotification.version_info) + return version_info_; +} +inline ::bgs::protocol::authentication::v1::VersionInfo* VersionInfoNotification::release_version_info() { + clear_has_version_info(); + ::bgs::protocol::authentication::v1::VersionInfo* temp = version_info_; + version_info_ = NULL; + return temp; +} +inline void VersionInfoNotification::set_allocated_version_info(::bgs::protocol::authentication::v1::VersionInfo* version_info) { + delete version_info_; + version_info_ = version_info; + if (version_info) { + set_has_version_info(); + } else { + clear_has_version_info(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.VersionInfoNotification.version_info) +} + +// ------------------------------------------------------------------- + +// MemModuleLoadRequest + +// required .bgs.protocol.ContentHandle handle = 1; +inline bool MemModuleLoadRequest::has_handle() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void MemModuleLoadRequest::set_has_handle() { + _has_bits_[0] |= 0x00000001u; +} +inline void MemModuleLoadRequest::clear_has_handle() { + _has_bits_[0] &= ~0x00000001u; +} +inline void MemModuleLoadRequest::clear_handle() { + if (handle_ != NULL) handle_->::bgs::protocol::ContentHandle::Clear(); + clear_has_handle(); +} +inline const ::bgs::protocol::ContentHandle& MemModuleLoadRequest::handle() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.MemModuleLoadRequest.handle) + return handle_ != NULL ? *handle_ : *default_instance_->handle_; +} +inline ::bgs::protocol::ContentHandle* MemModuleLoadRequest::mutable_handle() { + set_has_handle(); + if (handle_ == NULL) handle_ = new ::bgs::protocol::ContentHandle; + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.MemModuleLoadRequest.handle) + return handle_; +} +inline ::bgs::protocol::ContentHandle* MemModuleLoadRequest::release_handle() { + clear_has_handle(); + ::bgs::protocol::ContentHandle* temp = handle_; + handle_ = NULL; + return temp; +} +inline void MemModuleLoadRequest::set_allocated_handle(::bgs::protocol::ContentHandle* handle) { + delete handle_; + handle_ = handle; + if (handle) { + set_has_handle(); + } else { + clear_has_handle(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.MemModuleLoadRequest.handle) +} + +// required bytes key = 2; +inline bool MemModuleLoadRequest::has_key() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void MemModuleLoadRequest::set_has_key() { + _has_bits_[0] |= 0x00000002u; +} +inline void MemModuleLoadRequest::clear_has_key() { + _has_bits_[0] &= ~0x00000002u; +} +inline void MemModuleLoadRequest::clear_key() { + if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + key_->clear(); + } + clear_has_key(); +} +inline const ::std::string& MemModuleLoadRequest::key() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.MemModuleLoadRequest.key) + return *key_; +} +inline void MemModuleLoadRequest::set_key(const ::std::string& value) { + set_has_key(); + if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + key_ = new ::std::string; + } + key_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.MemModuleLoadRequest.key) +} +inline void MemModuleLoadRequest::set_key(const char* value) { + set_has_key(); + if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + key_ = new ::std::string; + } + key_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.MemModuleLoadRequest.key) +} +inline void MemModuleLoadRequest::set_key(const void* value, size_t size) { + set_has_key(); + if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + key_ = new ::std::string; + } + key_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.MemModuleLoadRequest.key) +} +inline ::std::string* MemModuleLoadRequest::mutable_key() { + set_has_key(); + if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + key_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.MemModuleLoadRequest.key) + return key_; +} +inline ::std::string* MemModuleLoadRequest::release_key() { + clear_has_key(); + if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = key_; + key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void MemModuleLoadRequest::set_allocated_key(::std::string* key) { + if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete key_; + } + if (key) { + set_has_key(); + key_ = key; + } else { + clear_has_key(); + key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.MemModuleLoadRequest.key) +} + +// required bytes input = 3; +inline bool MemModuleLoadRequest::has_input() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void MemModuleLoadRequest::set_has_input() { + _has_bits_[0] |= 0x00000004u; +} +inline void MemModuleLoadRequest::clear_has_input() { + _has_bits_[0] &= ~0x00000004u; +} +inline void MemModuleLoadRequest::clear_input() { + if (input_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + input_->clear(); + } + clear_has_input(); +} +inline const ::std::string& MemModuleLoadRequest::input() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.MemModuleLoadRequest.input) + return *input_; +} +inline void MemModuleLoadRequest::set_input(const ::std::string& value) { + set_has_input(); + if (input_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + input_ = new ::std::string; + } + input_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.MemModuleLoadRequest.input) +} +inline void MemModuleLoadRequest::set_input(const char* value) { + set_has_input(); + if (input_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + input_ = new ::std::string; + } + input_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.MemModuleLoadRequest.input) +} +inline void MemModuleLoadRequest::set_input(const void* value, size_t size) { + set_has_input(); + if (input_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + input_ = new ::std::string; + } + input_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.MemModuleLoadRequest.input) +} +inline ::std::string* MemModuleLoadRequest::mutable_input() { + set_has_input(); + if (input_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + input_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.MemModuleLoadRequest.input) + return input_; +} +inline ::std::string* MemModuleLoadRequest::release_input() { + clear_has_input(); + if (input_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = input_; + input_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void MemModuleLoadRequest::set_allocated_input(::std::string* input) { + if (input_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete input_; + } + if (input) { + set_has_input(); + input_ = input; + } else { + clear_has_input(); + input_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.MemModuleLoadRequest.input) +} + +// ------------------------------------------------------------------- + +// MemModuleLoadResponse + +// required bytes data = 1; +inline bool MemModuleLoadResponse::has_data() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void MemModuleLoadResponse::set_has_data() { + _has_bits_[0] |= 0x00000001u; +} +inline void MemModuleLoadResponse::clear_has_data() { + _has_bits_[0] &= ~0x00000001u; +} +inline void MemModuleLoadResponse::clear_data() { + if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_->clear(); + } + clear_has_data(); +} +inline const ::std::string& MemModuleLoadResponse::data() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.MemModuleLoadResponse.data) + return *data_; +} +inline void MemModuleLoadResponse::set_data(const ::std::string& value) { + set_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_ = new ::std::string; + } + data_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.MemModuleLoadResponse.data) +} +inline void MemModuleLoadResponse::set_data(const char* value) { + set_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_ = new ::std::string; + } + data_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.MemModuleLoadResponse.data) +} +inline void MemModuleLoadResponse::set_data(const void* value, size_t size) { + set_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_ = new ::std::string; + } + data_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.MemModuleLoadResponse.data) +} +inline ::std::string* MemModuleLoadResponse::mutable_data() { + set_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.MemModuleLoadResponse.data) + return data_; +} +inline ::std::string* MemModuleLoadResponse::release_data() { + clear_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = data_; + data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void MemModuleLoadResponse::set_allocated_data(::std::string* data) { + if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete data_; + } + if (data) { + set_has_data(); + data_ = data; + } else { + clear_has_data(); + data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.MemModuleLoadResponse.data) +} + +// ------------------------------------------------------------------- + +// SelectGameAccountRequest + +// required .bgs.protocol.EntityId game_account_id = 1; +inline bool SelectGameAccountRequest::has_game_account_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SelectGameAccountRequest::set_has_game_account_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void SelectGameAccountRequest::clear_has_game_account_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SelectGameAccountRequest::clear_game_account_id() { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_game_account_id(); +} +inline const ::bgs::protocol::EntityId& SelectGameAccountRequest::game_account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.SelectGameAccountRequest.game_account_id) + return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_; +} +inline ::bgs::protocol::EntityId* SelectGameAccountRequest::mutable_game_account_id() { + set_has_game_account_id(); + if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.SelectGameAccountRequest.game_account_id) + return game_account_id_; +} +inline ::bgs::protocol::EntityId* SelectGameAccountRequest::release_game_account_id() { + clear_has_game_account_id(); + ::bgs::protocol::EntityId* temp = game_account_id_; + game_account_id_ = NULL; + return temp; +} +inline void SelectGameAccountRequest::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) { + delete game_account_id_; + game_account_id_ = game_account_id; + if (game_account_id) { + set_has_game_account_id(); + } else { + clear_has_game_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.SelectGameAccountRequest.game_account_id) +} + +// ------------------------------------------------------------------- + +// GameAccountSelectedRequest + +// required uint32 result = 1; +inline bool GameAccountSelectedRequest::has_result() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GameAccountSelectedRequest::set_has_result() { + _has_bits_[0] |= 0x00000001u; +} +inline void GameAccountSelectedRequest::clear_has_result() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GameAccountSelectedRequest::clear_result() { + result_ = 0u; + clear_has_result(); +} +inline ::google::protobuf::uint32 GameAccountSelectedRequest::result() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.GameAccountSelectedRequest.result) + return result_; +} +inline void GameAccountSelectedRequest::set_result(::google::protobuf::uint32 value) { + set_has_result(); + result_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.GameAccountSelectedRequest.result) +} + +// optional .bgs.protocol.EntityId game_account_id = 2; +inline bool GameAccountSelectedRequest::has_game_account_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GameAccountSelectedRequest::set_has_game_account_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void GameAccountSelectedRequest::clear_has_game_account_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GameAccountSelectedRequest::clear_game_account_id() { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_game_account_id(); +} +inline const ::bgs::protocol::EntityId& GameAccountSelectedRequest::game_account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.GameAccountSelectedRequest.game_account_id) + return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_; +} +inline ::bgs::protocol::EntityId* GameAccountSelectedRequest::mutable_game_account_id() { + set_has_game_account_id(); + if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.GameAccountSelectedRequest.game_account_id) + return game_account_id_; +} +inline ::bgs::protocol::EntityId* GameAccountSelectedRequest::release_game_account_id() { + clear_has_game_account_id(); + ::bgs::protocol::EntityId* temp = game_account_id_; + game_account_id_ = NULL; + return temp; +} +inline void GameAccountSelectedRequest::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) { + delete game_account_id_; + game_account_id_ = game_account_id; + if (game_account_id) { + set_has_game_account_id(); + } else { + clear_has_game_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.GameAccountSelectedRequest.game_account_id) +} + +// ------------------------------------------------------------------- + +// GenerateWebCredentialsRequest + +// optional fixed32 program = 1; +inline bool GenerateWebCredentialsRequest::has_program() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GenerateWebCredentialsRequest::set_has_program() { + _has_bits_[0] |= 0x00000001u; +} +inline void GenerateWebCredentialsRequest::clear_has_program() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GenerateWebCredentialsRequest::clear_program() { + program_ = 0u; + clear_has_program(); +} +inline ::google::protobuf::uint32 GenerateWebCredentialsRequest::program() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest.program) + return program_; +} +inline void GenerateWebCredentialsRequest::set_program(::google::protobuf::uint32 value) { + set_has_program(); + program_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest.program) +} + +// ------------------------------------------------------------------- + +// GenerateWebCredentialsResponse + +// optional bytes web_credentials = 1; +inline bool GenerateWebCredentialsResponse::has_web_credentials() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GenerateWebCredentialsResponse::set_has_web_credentials() { + _has_bits_[0] |= 0x00000001u; +} +inline void GenerateWebCredentialsResponse::clear_has_web_credentials() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GenerateWebCredentialsResponse::clear_web_credentials() { + if (web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + web_credentials_->clear(); + } + clear_has_web_credentials(); +} +inline const ::std::string& GenerateWebCredentialsResponse::web_credentials() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse.web_credentials) + return *web_credentials_; +} +inline void GenerateWebCredentialsResponse::set_web_credentials(const ::std::string& value) { + set_has_web_credentials(); + if (web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + web_credentials_ = new ::std::string; + } + web_credentials_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse.web_credentials) +} +inline void GenerateWebCredentialsResponse::set_web_credentials(const char* value) { + set_has_web_credentials(); + if (web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + web_credentials_ = new ::std::string; + } + web_credentials_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse.web_credentials) +} +inline void GenerateWebCredentialsResponse::set_web_credentials(const void* value, size_t size) { + set_has_web_credentials(); + if (web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + web_credentials_ = new ::std::string; + } + web_credentials_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse.web_credentials) +} +inline ::std::string* GenerateWebCredentialsResponse::mutable_web_credentials() { + set_has_web_credentials(); + if (web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + web_credentials_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse.web_credentials) + return web_credentials_; +} +inline ::std::string* GenerateWebCredentialsResponse::release_web_credentials() { + clear_has_web_credentials(); + if (web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = web_credentials_; + web_credentials_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void GenerateWebCredentialsResponse::set_allocated_web_credentials(::std::string* web_credentials) { + if (web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete web_credentials_; + } + if (web_credentials) { + set_has_web_credentials(); + web_credentials_ = web_credentials; + } else { + clear_has_web_credentials(); + web_credentials_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse.web_credentials) +} + +// ------------------------------------------------------------------- + +// VerifyWebCredentialsRequest + +// optional bytes web_credentials = 1; +inline bool VerifyWebCredentialsRequest::has_web_credentials() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void VerifyWebCredentialsRequest::set_has_web_credentials() { + _has_bits_[0] |= 0x00000001u; +} +inline void VerifyWebCredentialsRequest::clear_has_web_credentials() { + _has_bits_[0] &= ~0x00000001u; +} +inline void VerifyWebCredentialsRequest::clear_web_credentials() { + if (web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + web_credentials_->clear(); + } + clear_has_web_credentials(); +} +inline const ::std::string& VerifyWebCredentialsRequest::web_credentials() const { + // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest.web_credentials) + return *web_credentials_; +} +inline void VerifyWebCredentialsRequest::set_web_credentials(const ::std::string& value) { + set_has_web_credentials(); + if (web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + web_credentials_ = new ::std::string; + } + web_credentials_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest.web_credentials) +} +inline void VerifyWebCredentialsRequest::set_web_credentials(const char* value) { + set_has_web_credentials(); + if (web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + web_credentials_ = new ::std::string; + } + web_credentials_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest.web_credentials) +} +inline void VerifyWebCredentialsRequest::set_web_credentials(const void* value, size_t size) { + set_has_web_credentials(); + if (web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + web_credentials_ = new ::std::string; + } + web_credentials_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest.web_credentials) +} +inline ::std::string* VerifyWebCredentialsRequest::mutable_web_credentials() { + set_has_web_credentials(); + if (web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + web_credentials_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest.web_credentials) + return web_credentials_; +} +inline ::std::string* VerifyWebCredentialsRequest::release_web_credentials() { + clear_has_web_credentials(); + if (web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = web_credentials_; + web_credentials_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void VerifyWebCredentialsRequest::set_allocated_web_credentials(::std::string* web_credentials) { + if (web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete web_credentials_; + } + if (web_credentials) { + set_has_web_credentials(); + web_credentials_ = web_credentials; + } else { + clear_has_web_credentials(); + web_credentials_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest.web_credentials) +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace authentication +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_authentication_5fservice_2eproto__INCLUDED diff --git a/src/server/proto/Client/challenge_service.pb.cc b/src/server/proto/Client/challenge_service.pb.cc new file mode 100644 index 00000000000..c42f5e4f967 --- /dev/null +++ b/src/server/proto/Client/challenge_service.pb.cc @@ -0,0 +1,4746 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: challenge_service.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "challenge_service.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +#include "BattlenetRpcErrorCodes.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { +namespace challenge { +namespace v1 { + +namespace { + +const ::google::protobuf::Descriptor* Challenge_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Challenge_reflection_ = NULL; +const ::google::protobuf::Descriptor* ChallengePickedRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ChallengePickedRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* ChallengePickedResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ChallengePickedResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* ChallengeAnsweredRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ChallengeAnsweredRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* ChallengeAnsweredResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ChallengeAnsweredResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* ChallengeCancelledRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ChallengeCancelledRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* SendChallengeToUserRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SendChallengeToUserRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* SendChallengeToUserResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SendChallengeToUserResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* ChallengeUserRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ChallengeUserRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* ChallengeResultRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ChallengeResultRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* ChallengeExternalRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ChallengeExternalRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* ChallengeExternalResult_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ChallengeExternalResult_reflection_ = NULL; +const ::google::protobuf::ServiceDescriptor* ChallengeService_descriptor_ = NULL; +const ::google::protobuf::ServiceDescriptor* ChallengeListener_descriptor_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_challenge_5fservice_2eproto() { + protobuf_AddDesc_challenge_5fservice_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "challenge_service.proto"); + GOOGLE_CHECK(file != NULL); + Challenge_descriptor_ = file->message_type(0); + static const int Challenge_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Challenge, type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Challenge, info_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Challenge, answer_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Challenge, retries_), + }; + Challenge_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Challenge_descriptor_, + Challenge::default_instance_, + Challenge_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Challenge, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Challenge, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Challenge)); + ChallengePickedRequest_descriptor_ = file->message_type(1); + static const int ChallengePickedRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengePickedRequest, challenge_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengePickedRequest, id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengePickedRequest, new_challenge_protocol_), + }; + ChallengePickedRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ChallengePickedRequest_descriptor_, + ChallengePickedRequest::default_instance_, + ChallengePickedRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengePickedRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengePickedRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ChallengePickedRequest)); + ChallengePickedResponse_descriptor_ = file->message_type(2); + static const int ChallengePickedResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengePickedResponse, data_), + }; + ChallengePickedResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ChallengePickedResponse_descriptor_, + ChallengePickedResponse::default_instance_, + ChallengePickedResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengePickedResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengePickedResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ChallengePickedResponse)); + ChallengeAnsweredRequest_descriptor_ = file->message_type(3); + static const int ChallengeAnsweredRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredRequest, answer_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredRequest, data_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredRequest, id_), + }; + ChallengeAnsweredRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ChallengeAnsweredRequest_descriptor_, + ChallengeAnsweredRequest::default_instance_, + ChallengeAnsweredRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ChallengeAnsweredRequest)); + ChallengeAnsweredResponse_descriptor_ = file->message_type(4); + static const int ChallengeAnsweredResponse_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredResponse, data_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredResponse, do_retry_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredResponse, record_not_found_), + }; + ChallengeAnsweredResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ChallengeAnsweredResponse_descriptor_, + ChallengeAnsweredResponse::default_instance_, + ChallengeAnsweredResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ChallengeAnsweredResponse)); + ChallengeCancelledRequest_descriptor_ = file->message_type(5); + static const int ChallengeCancelledRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeCancelledRequest, id_), + }; + ChallengeCancelledRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ChallengeCancelledRequest_descriptor_, + ChallengeCancelledRequest::default_instance_, + ChallengeCancelledRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeCancelledRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeCancelledRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ChallengeCancelledRequest)); + SendChallengeToUserRequest_descriptor_ = file->message_type(6); + static const int SendChallengeToUserRequest_offsets_[8] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, peer_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, game_account_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, challenges_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, context_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, timeout_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, attributes_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, host_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, account_id_), + }; + SendChallengeToUserRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + SendChallengeToUserRequest_descriptor_, + SendChallengeToUserRequest::default_instance_, + SendChallengeToUserRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(SendChallengeToUserRequest)); + SendChallengeToUserResponse_descriptor_ = file->message_type(7); + static const int SendChallengeToUserResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserResponse, id_), + }; + SendChallengeToUserResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + SendChallengeToUserResponse_descriptor_, + SendChallengeToUserResponse::default_instance_, + SendChallengeToUserResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(SendChallengeToUserResponse)); + ChallengeUserRequest_descriptor_ = file->message_type(8); + static const int ChallengeUserRequest_offsets_[6] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeUserRequest, challenges_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeUserRequest, context_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeUserRequest, id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeUserRequest, deadline_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeUserRequest, attributes_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeUserRequest, game_account_id_), + }; + ChallengeUserRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ChallengeUserRequest_descriptor_, + ChallengeUserRequest::default_instance_, + ChallengeUserRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeUserRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeUserRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ChallengeUserRequest)); + ChallengeResultRequest_descriptor_ = file->message_type(9); + static const int ChallengeResultRequest_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeResultRequest, id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeResultRequest, type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeResultRequest, error_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeResultRequest, answer_), + }; + ChallengeResultRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ChallengeResultRequest_descriptor_, + ChallengeResultRequest::default_instance_, + ChallengeResultRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeResultRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeResultRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ChallengeResultRequest)); + ChallengeExternalRequest_descriptor_ = file->message_type(10); + static const int ChallengeExternalRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeExternalRequest, request_token_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeExternalRequest, payload_type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeExternalRequest, payload_), + }; + ChallengeExternalRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ChallengeExternalRequest_descriptor_, + ChallengeExternalRequest::default_instance_, + ChallengeExternalRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeExternalRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeExternalRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ChallengeExternalRequest)); + ChallengeExternalResult_descriptor_ = file->message_type(11); + static const int ChallengeExternalResult_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeExternalResult, request_token_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeExternalResult, passed_), + }; + ChallengeExternalResult_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ChallengeExternalResult_descriptor_, + ChallengeExternalResult::default_instance_, + ChallengeExternalResult_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeExternalResult, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeExternalResult, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ChallengeExternalResult)); + ChallengeService_descriptor_ = file->service(0); + ChallengeListener_descriptor_ = file->service(1); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_challenge_5fservice_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Challenge_descriptor_, &Challenge::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ChallengePickedRequest_descriptor_, &ChallengePickedRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ChallengePickedResponse_descriptor_, &ChallengePickedResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ChallengeAnsweredRequest_descriptor_, &ChallengeAnsweredRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ChallengeAnsweredResponse_descriptor_, &ChallengeAnsweredResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ChallengeCancelledRequest_descriptor_, &ChallengeCancelledRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SendChallengeToUserRequest_descriptor_, &SendChallengeToUserRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SendChallengeToUserResponse_descriptor_, &SendChallengeToUserResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ChallengeUserRequest_descriptor_, &ChallengeUserRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ChallengeResultRequest_descriptor_, &ChallengeResultRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ChallengeExternalRequest_descriptor_, &ChallengeExternalRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ChallengeExternalResult_descriptor_, &ChallengeExternalResult::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_challenge_5fservice_2eproto() { + delete Challenge::default_instance_; + delete Challenge_reflection_; + delete ChallengePickedRequest::default_instance_; + delete ChallengePickedRequest_reflection_; + delete ChallengePickedResponse::default_instance_; + delete ChallengePickedResponse_reflection_; + delete ChallengeAnsweredRequest::default_instance_; + delete ChallengeAnsweredRequest_reflection_; + delete ChallengeAnsweredResponse::default_instance_; + delete ChallengeAnsweredResponse_reflection_; + delete ChallengeCancelledRequest::default_instance_; + delete ChallengeCancelledRequest_reflection_; + delete SendChallengeToUserRequest::default_instance_; + delete SendChallengeToUserRequest_reflection_; + delete SendChallengeToUserResponse::default_instance_; + delete SendChallengeToUserResponse_reflection_; + delete ChallengeUserRequest::default_instance_; + delete ChallengeUserRequest_reflection_; + delete ChallengeResultRequest::default_instance_; + delete ChallengeResultRequest_reflection_; + delete ChallengeExternalRequest::default_instance_; + delete ChallengeExternalRequest_reflection_; + delete ChallengeExternalResult::default_instance_; + delete ChallengeExternalResult_reflection_; +} + +void protobuf_AddDesc_challenge_5fservice_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\027challenge_service.proto\022\031bgs.protocol." + "challenge.v1\032\025attribute_types.proto\032\022ent" + "ity_types.proto\032\017rpc_types.proto\"N\n\tChal" + "lenge\022\014\n\004type\030\001 \002(\007\022\014\n\004info\030\002 \001(\t\022\024\n\006ans" + "wer\030\003 \001(\tB\004\200\265\030\001\022\017\n\007retries\030\004 \001(\r\"^\n\026Chal" + "lengePickedRequest\022\021\n\tchallenge\030\001 \002(\007\022\n\n" + "\002id\030\002 \001(\r\022%\n\026new_challenge_protocol\030\003 \001(" + "\010:\005false\"-\n\027ChallengePickedResponse\022\022\n\004d" + "ata\030\001 \001(\014B\004\200\265\030\001\"P\n\030ChallengeAnsweredRequ" + "est\022\024\n\006answer\030\001 \002(\tB\004\200\265\030\001\022\022\n\004data\030\002 \001(\014B" + "\004\200\265\030\001\022\n\n\002id\030\003 \001(\r\"[\n\031ChallengeAnsweredRe" + "sponse\022\022\n\004data\030\001 \001(\014B\004\200\265\030\001\022\020\n\010do_retry\030\002" + " \001(\010\022\030\n\020record_not_found\030\003 \001(\010\"\'\n\031Challe" + "ngeCancelledRequest\022\n\n\002id\030\001 \001(\r\"\323\002\n\032Send" + "ChallengeToUserRequest\022(\n\007peer_id\030\001 \001(\0132" + "\027.bgs.protocol.ProcessId\022/\n\017game_account" + "_id\030\002 \001(\0132\026.bgs.protocol.EntityId\0228\n\ncha" + "llenges\030\003 \003(\0132$.bgs.protocol.challenge.v" + "1.Challenge\022\017\n\007context\030\004 \002(\007\022\017\n\007timeout\030" + "\005 \001(\004\022+\n\nattributes\030\006 \003(\0132\027.bgs.protocol" + ".Attribute\022%\n\004host\030\007 \001(\0132\027.bgs.protocol." + "ProcessId\022*\n\naccount_id\030\010 \001(\0132\026.bgs.prot" + "ocol.EntityId\")\n\033SendChallengeToUserResp" + "onse\022\n\n\002id\030\001 \001(\r\"\335\001\n\024ChallengeUserReques" + "t\0228\n\nchallenges\030\001 \003(\0132$.bgs.protocol.cha" + "llenge.v1.Challenge\022\017\n\007context\030\002 \002(\007\022\n\n\002" + "id\030\003 \001(\r\022\020\n\010deadline\030\004 \001(\004\022+\n\nattributes" + "\030\005 \003(\0132\027.bgs.protocol.Attribute\022/\n\017game_" + "account_id\030\006 \001(\0132\026.bgs.protocol.EntityId" + "\"Z\n\026ChallengeResultRequest\022\n\n\002id\030\001 \001(\r\022\014" + "\n\004type\030\002 \001(\007\022\020\n\010error_id\030\003 \001(\r\022\024\n\006answer" + "\030\004 \001(\014B\004\200\265\030\001\"X\n\030ChallengeExternalRequest" + "\022\025\n\rrequest_token\030\001 \001(\t\022\024\n\014payload_type\030" + "\002 \001(\t\022\017\n\007payload\030\003 \001(\014\"F\n\027ChallengeExter" + "nalResult\022\025\n\rrequest_token\030\001 \001(\t\022\024\n\006pass" + "ed\030\002 \001(\010:\004true2\273\004\n\020ChallengeService\022~\n\017C" + "hallengePicked\0221.bgs.protocol.challenge." + "v1.ChallengePickedRequest\0322.bgs.protocol" + ".challenge.v1.ChallengePickedResponse\"\004\200" + "\265\030\001\022\204\001\n\021ChallengeAnswered\0223.bgs.protocol" + ".challenge.v1.ChallengeAnsweredRequest\0324" + ".bgs.protocol.challenge.v1.ChallengeAnsw" + "eredResponse\"\004\200\265\030\002\022f\n\022ChallengeCancelled" + "\0224.bgs.protocol.challenge.v1.ChallengeCa" + "ncelledRequest\032\024.bgs.protocol.NoData\"\004\200\265" + "\030\003\022\212\001\n\023SendChallengeToUser\0225.bgs.protoco" + "l.challenge.v1.SendChallengeToUserReques" + "t\0326.bgs.protocol.challenge.v1.SendChalle" + "ngeToUserResponse\"\004\200\265\030\004\032+\312>(bnet.protoco" + "l.challenge.ChallengeService2\354\003\n\021Challen" + "geListener\022c\n\017OnChallengeUser\022/.bgs.prot" + "ocol.challenge.v1.ChallengeUserRequest\032\031" + ".bgs.protocol.NO_RESPONSE\"\004\200\265\030\001\022g\n\021OnCha" + "llengeResult\0221.bgs.protocol.challenge.v1" + ".ChallengeResultRequest\032\031.bgs.protocol.N" + "O_RESPONSE\"\004\200\265\030\002\022k\n\023OnExternalChallenge\022" + "3.bgs.protocol.challenge.v1.ChallengeExt" + "ernalRequest\032\031.bgs.protocol.NO_RESPONSE\"" + "\004\200\265\030\003\022p\n\031OnExternalChallengeResult\0222.bgs" + ".protocol.challenge.v1.ChallengeExternal" + "Result\032\031.bgs.protocol.NO_RESPONSE\"\004\200\265\030\004\032" + "*\312>\'bnet.protocol.challenge.ChallengeNot" + "ifyB\005H\001\200\001\000", 2490); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "challenge_service.proto", &protobuf_RegisterTypes); + Challenge::default_instance_ = new Challenge(); + ChallengePickedRequest::default_instance_ = new ChallengePickedRequest(); + ChallengePickedResponse::default_instance_ = new ChallengePickedResponse(); + ChallengeAnsweredRequest::default_instance_ = new ChallengeAnsweredRequest(); + ChallengeAnsweredResponse::default_instance_ = new ChallengeAnsweredResponse(); + ChallengeCancelledRequest::default_instance_ = new ChallengeCancelledRequest(); + SendChallengeToUserRequest::default_instance_ = new SendChallengeToUserRequest(); + SendChallengeToUserResponse::default_instance_ = new SendChallengeToUserResponse(); + ChallengeUserRequest::default_instance_ = new ChallengeUserRequest(); + ChallengeResultRequest::default_instance_ = new ChallengeResultRequest(); + ChallengeExternalRequest::default_instance_ = new ChallengeExternalRequest(); + ChallengeExternalResult::default_instance_ = new ChallengeExternalResult(); + Challenge::default_instance_->InitAsDefaultInstance(); + ChallengePickedRequest::default_instance_->InitAsDefaultInstance(); + ChallengePickedResponse::default_instance_->InitAsDefaultInstance(); + ChallengeAnsweredRequest::default_instance_->InitAsDefaultInstance(); + ChallengeAnsweredResponse::default_instance_->InitAsDefaultInstance(); + ChallengeCancelledRequest::default_instance_->InitAsDefaultInstance(); + SendChallengeToUserRequest::default_instance_->InitAsDefaultInstance(); + SendChallengeToUserResponse::default_instance_->InitAsDefaultInstance(); + ChallengeUserRequest::default_instance_->InitAsDefaultInstance(); + ChallengeResultRequest::default_instance_->InitAsDefaultInstance(); + ChallengeExternalRequest::default_instance_->InitAsDefaultInstance(); + ChallengeExternalResult::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_challenge_5fservice_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_challenge_5fservice_2eproto { + StaticDescriptorInitializer_challenge_5fservice_2eproto() { + protobuf_AddDesc_challenge_5fservice_2eproto(); + } +} static_descriptor_initializer_challenge_5fservice_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int Challenge::kTypeFieldNumber; +const int Challenge::kInfoFieldNumber; +const int Challenge::kAnswerFieldNumber; +const int Challenge::kRetriesFieldNumber; +#endif // !_MSC_VER + +Challenge::Challenge() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.Challenge) +} + +void Challenge::InitAsDefaultInstance() { +} + +Challenge::Challenge(const Challenge& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.Challenge) +} + +void Challenge::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + type_ = 0u; + info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + retries_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Challenge::~Challenge() { + // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.Challenge) + SharedDtor(); +} + +void Challenge::SharedDtor() { + if (info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete info_; + } + if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete answer_; + } + if (this != default_instance_) { + } +} + +void Challenge::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Challenge::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Challenge_descriptor_; +} + +const Challenge& Challenge::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto(); + return *default_instance_; +} + +Challenge* Challenge::default_instance_ = NULL; + +Challenge* Challenge::New() const { + return new Challenge; +} + +void Challenge::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(type_, retries_); + if (has_info()) { + if (info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + info_->clear(); + } + } + if (has_answer()) { + if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + answer_->clear(); + } + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Challenge::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.Challenge) + 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)) { + // required fixed32 type = 1; + case 1: { + if (tag == 13) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &type_))); + set_has_type(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_info; + break; + } + + // optional string info = 2; + case 2: { + if (tag == 18) { + parse_info: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_info())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->info().data(), this->info().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "info"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_answer; + break; + } + + // optional string answer = 3; + case 3: { + if (tag == 26) { + parse_answer: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_answer())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->answer().data(), this->answer().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "answer"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_retries; + break; + } + + // optional uint32 retries = 4; + case 4: { + if (tag == 32) { + parse_retries: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &retries_))); + set_has_retries(); + } 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:bgs.protocol.challenge.v1.Challenge) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.Challenge) + return false; +#undef DO_ +} + +void Challenge::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.Challenge) + // required fixed32 type = 1; + if (has_type()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->type(), output); + } + + // optional string info = 2; + if (has_info()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->info().data(), this->info().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "info"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->info(), output); + } + + // optional string answer = 3; + if (has_answer()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->answer().data(), this->answer().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "answer"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->answer(), output); + } + + // optional uint32 retries = 4; + if (has_retries()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->retries(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.Challenge) +} + +::google::protobuf::uint8* Challenge::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.Challenge) + // required fixed32 type = 1; + if (has_type()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->type(), target); + } + + // optional string info = 2; + if (has_info()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->info().data(), this->info().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "info"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->info(), target); + } + + // optional string answer = 3; + if (has_answer()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->answer().data(), this->answer().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "answer"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->answer(), target); + } + + // optional uint32 retries = 4; + if (has_retries()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->retries(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.Challenge) + return target; +} + +int Challenge::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed32 type = 1; + if (has_type()) { + total_size += 1 + 4; + } + + // optional string info = 2; + if (has_info()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->info()); + } + + // optional string answer = 3; + if (has_answer()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->answer()); + } + + // optional uint32 retries = 4; + if (has_retries()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->retries()); + } + + } + 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 Challenge::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Challenge* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Challenge::MergeFrom(const Challenge& 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_info()) { + set_info(from.info()); + } + if (from.has_answer()) { + set_answer(from.answer()); + } + if (from.has_retries()) { + set_retries(from.retries()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Challenge::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Challenge::CopyFrom(const Challenge& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Challenge::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void Challenge::Swap(Challenge* other) { + if (other != this) { + std::swap(type_, other->type_); + std::swap(info_, other->info_); + std::swap(answer_, other->answer_); + std::swap(retries_, other->retries_); + 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 Challenge::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Challenge_descriptor_; + metadata.reflection = Challenge_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ChallengePickedRequest::kChallengeFieldNumber; +const int ChallengePickedRequest::kIdFieldNumber; +const int ChallengePickedRequest::kNewChallengeProtocolFieldNumber; +#endif // !_MSC_VER + +ChallengePickedRequest::ChallengePickedRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengePickedRequest) +} + +void ChallengePickedRequest::InitAsDefaultInstance() { +} + +ChallengePickedRequest::ChallengePickedRequest(const ChallengePickedRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengePickedRequest) +} + +void ChallengePickedRequest::SharedCtor() { + _cached_size_ = 0; + challenge_ = 0u; + id_ = 0u; + new_challenge_protocol_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ChallengePickedRequest::~ChallengePickedRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengePickedRequest) + SharedDtor(); +} + +void ChallengePickedRequest::SharedDtor() { + if (this != default_instance_) { + } +} + +void ChallengePickedRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ChallengePickedRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ChallengePickedRequest_descriptor_; +} + +const ChallengePickedRequest& ChallengePickedRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto(); + return *default_instance_; +} + +ChallengePickedRequest* ChallengePickedRequest::default_instance_ = NULL; + +ChallengePickedRequest* ChallengePickedRequest::New() const { + return new ChallengePickedRequest; +} + +void ChallengePickedRequest::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(challenge_, new_challenge_protocol_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ChallengePickedRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengePickedRequest) + 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)) { + // required fixed32 challenge = 1; + case 1: { + if (tag == 13) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &challenge_))); + set_has_challenge(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_id; + break; + } + + // optional uint32 id = 2; + case 2: { + if (tag == 16) { + parse_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &id_))); + set_has_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_new_challenge_protocol; + break; + } + + // optional bool new_challenge_protocol = 3 [default = false]; + case 3: { + if (tag == 24) { + parse_new_challenge_protocol: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &new_challenge_protocol_))); + set_has_new_challenge_protocol(); + } 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:bgs.protocol.challenge.v1.ChallengePickedRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengePickedRequest) + return false; +#undef DO_ +} + +void ChallengePickedRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengePickedRequest) + // required fixed32 challenge = 1; + if (has_challenge()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->challenge(), output); + } + + // optional uint32 id = 2; + if (has_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->id(), output); + } + + // optional bool new_challenge_protocol = 3 [default = false]; + if (has_new_challenge_protocol()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->new_challenge_protocol(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengePickedRequest) +} + +::google::protobuf::uint8* ChallengePickedRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengePickedRequest) + // required fixed32 challenge = 1; + if (has_challenge()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->challenge(), target); + } + + // optional uint32 id = 2; + if (has_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->id(), target); + } + + // optional bool new_challenge_protocol = 3 [default = false]; + if (has_new_challenge_protocol()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->new_challenge_protocol(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengePickedRequest) + return target; +} + +int ChallengePickedRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed32 challenge = 1; + if (has_challenge()) { + total_size += 1 + 4; + } + + // optional uint32 id = 2; + if (has_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->id()); + } + + // optional bool new_challenge_protocol = 3 [default = false]; + if (has_new_challenge_protocol()) { + 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 ChallengePickedRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ChallengePickedRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ChallengePickedRequest::MergeFrom(const ChallengePickedRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_challenge()) { + set_challenge(from.challenge()); + } + if (from.has_id()) { + set_id(from.id()); + } + if (from.has_new_challenge_protocol()) { + set_new_challenge_protocol(from.new_challenge_protocol()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ChallengePickedRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ChallengePickedRequest::CopyFrom(const ChallengePickedRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ChallengePickedRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void ChallengePickedRequest::Swap(ChallengePickedRequest* other) { + if (other != this) { + std::swap(challenge_, other->challenge_); + std::swap(id_, other->id_); + std::swap(new_challenge_protocol_, other->new_challenge_protocol_); + 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 ChallengePickedRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ChallengePickedRequest_descriptor_; + metadata.reflection = ChallengePickedRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ChallengePickedResponse::kDataFieldNumber; +#endif // !_MSC_VER + +ChallengePickedResponse::ChallengePickedResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengePickedResponse) +} + +void ChallengePickedResponse::InitAsDefaultInstance() { +} + +ChallengePickedResponse::ChallengePickedResponse(const ChallengePickedResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengePickedResponse) +} + +void ChallengePickedResponse::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ChallengePickedResponse::~ChallengePickedResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengePickedResponse) + SharedDtor(); +} + +void ChallengePickedResponse::SharedDtor() { + if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete data_; + } + if (this != default_instance_) { + } +} + +void ChallengePickedResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ChallengePickedResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ChallengePickedResponse_descriptor_; +} + +const ChallengePickedResponse& ChallengePickedResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto(); + return *default_instance_; +} + +ChallengePickedResponse* ChallengePickedResponse::default_instance_ = NULL; + +ChallengePickedResponse* ChallengePickedResponse::New() const { + return new ChallengePickedResponse; +} + +void ChallengePickedResponse::Clear() { + if (has_data()) { + if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_->clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ChallengePickedResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengePickedResponse) + 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->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:bgs.protocol.challenge.v1.ChallengePickedResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengePickedResponse) + return false; +#undef DO_ +} + +void ChallengePickedResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengePickedResponse) + // optional bytes data = 1; + if (has_data()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 1, this->data(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengePickedResponse) +} + +::google::protobuf::uint8* ChallengePickedResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengePickedResponse) + // optional bytes data = 1; + if (has_data()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 1, this->data(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengePickedResponse) + return target; +} + +int ChallengePickedResponse::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()); + } + + } + 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 ChallengePickedResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ChallengePickedResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ChallengePickedResponse::MergeFrom(const ChallengePickedResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_data()) { + set_data(from.data()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ChallengePickedResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ChallengePickedResponse::CopyFrom(const ChallengePickedResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ChallengePickedResponse::IsInitialized() const { + + return true; +} + +void ChallengePickedResponse::Swap(ChallengePickedResponse* other) { + if (other != this) { + 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 ChallengePickedResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ChallengePickedResponse_descriptor_; + metadata.reflection = ChallengePickedResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ChallengeAnsweredRequest::kAnswerFieldNumber; +const int ChallengeAnsweredRequest::kDataFieldNumber; +const int ChallengeAnsweredRequest::kIdFieldNumber; +#endif // !_MSC_VER + +ChallengeAnsweredRequest::ChallengeAnsweredRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengeAnsweredRequest) +} + +void ChallengeAnsweredRequest::InitAsDefaultInstance() { +} + +ChallengeAnsweredRequest::ChallengeAnsweredRequest(const ChallengeAnsweredRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengeAnsweredRequest) +} + +void ChallengeAnsweredRequest::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + id_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ChallengeAnsweredRequest::~ChallengeAnsweredRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengeAnsweredRequest) + SharedDtor(); +} + +void ChallengeAnsweredRequest::SharedDtor() { + if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete answer_; + } + if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete data_; + } + if (this != default_instance_) { + } +} + +void ChallengeAnsweredRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ChallengeAnsweredRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ChallengeAnsweredRequest_descriptor_; +} + +const ChallengeAnsweredRequest& ChallengeAnsweredRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto(); + return *default_instance_; +} + +ChallengeAnsweredRequest* ChallengeAnsweredRequest::default_instance_ = NULL; + +ChallengeAnsweredRequest* ChallengeAnsweredRequest::New() const { + return new ChallengeAnsweredRequest; +} + +void ChallengeAnsweredRequest::Clear() { + if (_has_bits_[0 / 32] & 7) { + if (has_answer()) { + if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + answer_->clear(); + } + } + if (has_data()) { + if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_->clear(); + } + } + id_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ChallengeAnsweredRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengeAnsweredRequest) + 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)) { + // required string answer = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_answer())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->answer().data(), this->answer().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "answer"); + } 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->ExpectTag(24)) goto parse_id; + break; + } + + // optional uint32 id = 3; + case 3: { + if (tag == 24) { + parse_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &id_))); + set_has_id(); + } 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:bgs.protocol.challenge.v1.ChallengeAnsweredRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengeAnsweredRequest) + return false; +#undef DO_ +} + +void ChallengeAnsweredRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengeAnsweredRequest) + // required string answer = 1; + if (has_answer()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->answer().data(), this->answer().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "answer"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->answer(), output); + } + + // optional bytes data = 2; + if (has_data()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 2, this->data(), output); + } + + // optional uint32 id = 3; + if (has_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengeAnsweredRequest) +} + +::google::protobuf::uint8* ChallengeAnsweredRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengeAnsweredRequest) + // required string answer = 1; + if (has_answer()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->answer().data(), this->answer().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "answer"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->answer(), target); + } + + // optional bytes data = 2; + if (has_data()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 2, this->data(), target); + } + + // optional uint32 id = 3; + if (has_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengeAnsweredRequest) + return target; +} + +int ChallengeAnsweredRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string answer = 1; + if (has_answer()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->answer()); + } + + // optional bytes data = 2; + if (has_data()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->data()); + } + + // optional uint32 id = 3; + if (has_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ChallengeAnsweredRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ChallengeAnsweredRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ChallengeAnsweredRequest::MergeFrom(const ChallengeAnsweredRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_answer()) { + set_answer(from.answer()); + } + if (from.has_data()) { + set_data(from.data()); + } + if (from.has_id()) { + set_id(from.id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ChallengeAnsweredRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ChallengeAnsweredRequest::CopyFrom(const ChallengeAnsweredRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ChallengeAnsweredRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void ChallengeAnsweredRequest::Swap(ChallengeAnsweredRequest* other) { + if (other != this) { + std::swap(answer_, other->answer_); + std::swap(data_, other->data_); + std::swap(id_, other->id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata ChallengeAnsweredRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ChallengeAnsweredRequest_descriptor_; + metadata.reflection = ChallengeAnsweredRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ChallengeAnsweredResponse::kDataFieldNumber; +const int ChallengeAnsweredResponse::kDoRetryFieldNumber; +const int ChallengeAnsweredResponse::kRecordNotFoundFieldNumber; +#endif // !_MSC_VER + +ChallengeAnsweredResponse::ChallengeAnsweredResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengeAnsweredResponse) +} + +void ChallengeAnsweredResponse::InitAsDefaultInstance() { +} + +ChallengeAnsweredResponse::ChallengeAnsweredResponse(const ChallengeAnsweredResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengeAnsweredResponse) +} + +void ChallengeAnsweredResponse::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + do_retry_ = false; + record_not_found_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ChallengeAnsweredResponse::~ChallengeAnsweredResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengeAnsweredResponse) + SharedDtor(); +} + +void ChallengeAnsweredResponse::SharedDtor() { + if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete data_; + } + if (this != default_instance_) { + } +} + +void ChallengeAnsweredResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ChallengeAnsweredResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ChallengeAnsweredResponse_descriptor_; +} + +const ChallengeAnsweredResponse& ChallengeAnsweredResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto(); + return *default_instance_; +} + +ChallengeAnsweredResponse* ChallengeAnsweredResponse::default_instance_ = NULL; + +ChallengeAnsweredResponse* ChallengeAnsweredResponse::New() const { + return new ChallengeAnsweredResponse; +} + +void ChallengeAnsweredResponse::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(do_retry_, record_not_found_); + 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 ChallengeAnsweredResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengeAnsweredResponse) + 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(16)) goto parse_do_retry; + break; + } + + // optional bool do_retry = 2; + case 2: { + if (tag == 16) { + parse_do_retry: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &do_retry_))); + set_has_do_retry(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_record_not_found; + break; + } + + // optional bool record_not_found = 3; + case 3: { + if (tag == 24) { + parse_record_not_found: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &record_not_found_))); + set_has_record_not_found(); + } 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:bgs.protocol.challenge.v1.ChallengeAnsweredResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengeAnsweredResponse) + return false; +#undef DO_ +} + +void ChallengeAnsweredResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengeAnsweredResponse) + // optional bytes data = 1; + if (has_data()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 1, this->data(), output); + } + + // optional bool do_retry = 2; + if (has_do_retry()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->do_retry(), output); + } + + // optional bool record_not_found = 3; + if (has_record_not_found()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->record_not_found(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengeAnsweredResponse) +} + +::google::protobuf::uint8* ChallengeAnsweredResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengeAnsweredResponse) + // optional bytes data = 1; + if (has_data()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 1, this->data(), target); + } + + // optional bool do_retry = 2; + if (has_do_retry()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->do_retry(), target); + } + + // optional bool record_not_found = 3; + if (has_record_not_found()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->record_not_found(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengeAnsweredResponse) + return target; +} + +int ChallengeAnsweredResponse::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 bool do_retry = 2; + if (has_do_retry()) { + total_size += 1 + 1; + } + + // optional bool record_not_found = 3; + if (has_record_not_found()) { + 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 ChallengeAnsweredResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ChallengeAnsweredResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ChallengeAnsweredResponse::MergeFrom(const ChallengeAnsweredResponse& 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_do_retry()) { + set_do_retry(from.do_retry()); + } + if (from.has_record_not_found()) { + set_record_not_found(from.record_not_found()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ChallengeAnsweredResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ChallengeAnsweredResponse::CopyFrom(const ChallengeAnsweredResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ChallengeAnsweredResponse::IsInitialized() const { + + return true; +} + +void ChallengeAnsweredResponse::Swap(ChallengeAnsweredResponse* other) { + if (other != this) { + std::swap(data_, other->data_); + std::swap(do_retry_, other->do_retry_); + std::swap(record_not_found_, other->record_not_found_); + 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 ChallengeAnsweredResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ChallengeAnsweredResponse_descriptor_; + metadata.reflection = ChallengeAnsweredResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ChallengeCancelledRequest::kIdFieldNumber; +#endif // !_MSC_VER + +ChallengeCancelledRequest::ChallengeCancelledRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengeCancelledRequest) +} + +void ChallengeCancelledRequest::InitAsDefaultInstance() { +} + +ChallengeCancelledRequest::ChallengeCancelledRequest(const ChallengeCancelledRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengeCancelledRequest) +} + +void ChallengeCancelledRequest::SharedCtor() { + _cached_size_ = 0; + id_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ChallengeCancelledRequest::~ChallengeCancelledRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengeCancelledRequest) + SharedDtor(); +} + +void ChallengeCancelledRequest::SharedDtor() { + if (this != default_instance_) { + } +} + +void ChallengeCancelledRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ChallengeCancelledRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ChallengeCancelledRequest_descriptor_; +} + +const ChallengeCancelledRequest& ChallengeCancelledRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto(); + return *default_instance_; +} + +ChallengeCancelledRequest* ChallengeCancelledRequest::default_instance_ = NULL; + +ChallengeCancelledRequest* ChallengeCancelledRequest::New() const { + return new ChallengeCancelledRequest; +} + +void ChallengeCancelledRequest::Clear() { + id_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ChallengeCancelledRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengeCancelledRequest) + 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 id = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &id_))); + set_has_id(); + } 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:bgs.protocol.challenge.v1.ChallengeCancelledRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengeCancelledRequest) + return false; +#undef DO_ +} + +void ChallengeCancelledRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengeCancelledRequest) + // optional uint32 id = 1; + if (has_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengeCancelledRequest) +} + +::google::protobuf::uint8* ChallengeCancelledRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengeCancelledRequest) + // optional uint32 id = 1; + if (has_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengeCancelledRequest) + return target; +} + +int ChallengeCancelledRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional uint32 id = 1; + if (has_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ChallengeCancelledRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ChallengeCancelledRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ChallengeCancelledRequest::MergeFrom(const ChallengeCancelledRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_id()) { + set_id(from.id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ChallengeCancelledRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ChallengeCancelledRequest::CopyFrom(const ChallengeCancelledRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ChallengeCancelledRequest::IsInitialized() const { + + return true; +} + +void ChallengeCancelledRequest::Swap(ChallengeCancelledRequest* other) { + if (other != this) { + std::swap(id_, other->id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata ChallengeCancelledRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ChallengeCancelledRequest_descriptor_; + metadata.reflection = ChallengeCancelledRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int SendChallengeToUserRequest::kPeerIdFieldNumber; +const int SendChallengeToUserRequest::kGameAccountIdFieldNumber; +const int SendChallengeToUserRequest::kChallengesFieldNumber; +const int SendChallengeToUserRequest::kContextFieldNumber; +const int SendChallengeToUserRequest::kTimeoutFieldNumber; +const int SendChallengeToUserRequest::kAttributesFieldNumber; +const int SendChallengeToUserRequest::kHostFieldNumber; +const int SendChallengeToUserRequest::kAccountIdFieldNumber; +#endif // !_MSC_VER + +SendChallengeToUserRequest::SendChallengeToUserRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.SendChallengeToUserRequest) +} + +void SendChallengeToUserRequest::InitAsDefaultInstance() { + peer_id_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance()); + game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + host_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance()); + account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +SendChallengeToUserRequest::SendChallengeToUserRequest(const SendChallengeToUserRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.SendChallengeToUserRequest) +} + +void SendChallengeToUserRequest::SharedCtor() { + _cached_size_ = 0; + peer_id_ = NULL; + game_account_id_ = NULL; + context_ = 0u; + timeout_ = GOOGLE_ULONGLONG(0); + host_ = NULL; + account_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +SendChallengeToUserRequest::~SendChallengeToUserRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.SendChallengeToUserRequest) + SharedDtor(); +} + +void SendChallengeToUserRequest::SharedDtor() { + if (this != default_instance_) { + delete peer_id_; + delete game_account_id_; + delete host_; + delete account_id_; + } +} + +void SendChallengeToUserRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SendChallengeToUserRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SendChallengeToUserRequest_descriptor_; +} + +const SendChallengeToUserRequest& SendChallengeToUserRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto(); + return *default_instance_; +} + +SendChallengeToUserRequest* SendChallengeToUserRequest::default_instance_ = NULL; + +SendChallengeToUserRequest* SendChallengeToUserRequest::New() const { + return new SendChallengeToUserRequest; +} + +void SendChallengeToUserRequest::Clear() { + if (_has_bits_[0 / 32] & 219) { + if (has_peer_id()) { + if (peer_id_ != NULL) peer_id_->::bgs::protocol::ProcessId::Clear(); + } + if (has_game_account_id()) { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + } + context_ = 0u; + timeout_ = GOOGLE_ULONGLONG(0); + if (has_host()) { + if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear(); + } + if (has_account_id()) { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + } + } + challenges_.Clear(); + attributes_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool SendChallengeToUserRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.SendChallengeToUserRequest) + 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 .bgs.protocol.ProcessId peer_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_peer_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_game_account_id; + break; + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + case 2: { + if (tag == 18) { + parse_game_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_challenges; + break; + } + + // repeated .bgs.protocol.challenge.v1.Challenge challenges = 3; + case 3: { + if (tag == 26) { + parse_challenges: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_challenges())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_challenges; + if (input->ExpectTag(37)) goto parse_context; + break; + } + + // required fixed32 context = 4; + case 4: { + if (tag == 37) { + parse_context: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &context_))); + set_has_context(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_timeout; + break; + } + + // optional uint64 timeout = 5; + case 5: { + if (tag == 40) { + parse_timeout: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &timeout_))); + set_has_timeout(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_attributes; + break; + } + + // repeated .bgs.protocol.Attribute attributes = 6; + case 6: { + if (tag == 50) { + parse_attributes: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_attributes())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_attributes; + if (input->ExpectTag(58)) goto parse_host; + break; + } + + // optional .bgs.protocol.ProcessId host = 7; + case 7: { + if (tag == 58) { + parse_host: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_host())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(66)) goto parse_account_id; + break; + } + + // optional .bgs.protocol.EntityId account_id = 8; + case 8: { + if (tag == 66) { + parse_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account_id())); + } 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:bgs.protocol.challenge.v1.SendChallengeToUserRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.SendChallengeToUserRequest) + return false; +#undef DO_ +} + +void SendChallengeToUserRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.SendChallengeToUserRequest) + // optional .bgs.protocol.ProcessId peer_id = 1; + if (has_peer_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->peer_id(), output); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->game_account_id(), output); + } + + // repeated .bgs.protocol.challenge.v1.Challenge challenges = 3; + for (int i = 0; i < this->challenges_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->challenges(i), output); + } + + // required fixed32 context = 4; + if (has_context()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->context(), output); + } + + // optional uint64 timeout = 5; + if (has_timeout()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(5, this->timeout(), output); + } + + // repeated .bgs.protocol.Attribute attributes = 6; + for (int i = 0; i < this->attributes_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, this->attributes(i), output); + } + + // optional .bgs.protocol.ProcessId host = 7; + if (has_host()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 7, this->host(), output); + } + + // optional .bgs.protocol.EntityId account_id = 8; + if (has_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 8, this->account_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.SendChallengeToUserRequest) +} + +::google::protobuf::uint8* SendChallengeToUserRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.SendChallengeToUserRequest) + // optional .bgs.protocol.ProcessId peer_id = 1; + if (has_peer_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->peer_id(), target); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->game_account_id(), target); + } + + // repeated .bgs.protocol.challenge.v1.Challenge challenges = 3; + for (int i = 0; i < this->challenges_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->challenges(i), target); + } + + // required fixed32 context = 4; + if (has_context()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->context(), target); + } + + // optional uint64 timeout = 5; + if (has_timeout()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(5, this->timeout(), target); + } + + // repeated .bgs.protocol.Attribute attributes = 6; + for (int i = 0; i < this->attributes_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 6, this->attributes(i), target); + } + + // optional .bgs.protocol.ProcessId host = 7; + if (has_host()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 7, this->host(), target); + } + + // optional .bgs.protocol.EntityId account_id = 8; + if (has_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 8, this->account_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.SendChallengeToUserRequest) + return target; +} + +int SendChallengeToUserRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.ProcessId peer_id = 1; + if (has_peer_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->peer_id()); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account_id()); + } + + // required fixed32 context = 4; + if (has_context()) { + total_size += 1 + 4; + } + + // optional uint64 timeout = 5; + if (has_timeout()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->timeout()); + } + + // optional .bgs.protocol.ProcessId host = 7; + if (has_host()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->host()); + } + + // optional .bgs.protocol.EntityId account_id = 8; + if (has_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account_id()); + } + + } + // repeated .bgs.protocol.challenge.v1.Challenge challenges = 3; + total_size += 1 * this->challenges_size(); + for (int i = 0; i < this->challenges_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->challenges(i)); + } + + // repeated .bgs.protocol.Attribute attributes = 6; + total_size += 1 * this->attributes_size(); + for (int i = 0; i < this->attributes_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->attributes(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 SendChallengeToUserRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const SendChallengeToUserRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void SendChallengeToUserRequest::MergeFrom(const SendChallengeToUserRequest& from) { + GOOGLE_CHECK_NE(&from, this); + challenges_.MergeFrom(from.challenges_); + attributes_.MergeFrom(from.attributes_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_peer_id()) { + mutable_peer_id()->::bgs::protocol::ProcessId::MergeFrom(from.peer_id()); + } + if (from.has_game_account_id()) { + mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id()); + } + if (from.has_context()) { + set_context(from.context()); + } + if (from.has_timeout()) { + set_timeout(from.timeout()); + } + if (from.has_host()) { + mutable_host()->::bgs::protocol::ProcessId::MergeFrom(from.host()); + } + if (from.has_account_id()) { + mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void SendChallengeToUserRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SendChallengeToUserRequest::CopyFrom(const SendChallengeToUserRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SendChallengeToUserRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000008) != 0x00000008) return false; + + if (has_peer_id()) { + if (!this->peer_id().IsInitialized()) return false; + } + if (has_game_account_id()) { + if (!this->game_account_id().IsInitialized()) return false; + } + if (!::google::protobuf::internal::AllAreInitialized(this->challenges())) return false; + if (!::google::protobuf::internal::AllAreInitialized(this->attributes())) return false; + if (has_host()) { + if (!this->host().IsInitialized()) return false; + } + if (has_account_id()) { + if (!this->account_id().IsInitialized()) return false; + } + return true; +} + +void SendChallengeToUserRequest::Swap(SendChallengeToUserRequest* other) { + if (other != this) { + std::swap(peer_id_, other->peer_id_); + std::swap(game_account_id_, other->game_account_id_); + challenges_.Swap(&other->challenges_); + std::swap(context_, other->context_); + std::swap(timeout_, other->timeout_); + attributes_.Swap(&other->attributes_); + std::swap(host_, other->host_); + std::swap(account_id_, other->account_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata SendChallengeToUserRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SendChallengeToUserRequest_descriptor_; + metadata.reflection = SendChallengeToUserRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int SendChallengeToUserResponse::kIdFieldNumber; +#endif // !_MSC_VER + +SendChallengeToUserResponse::SendChallengeToUserResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.SendChallengeToUserResponse) +} + +void SendChallengeToUserResponse::InitAsDefaultInstance() { +} + +SendChallengeToUserResponse::SendChallengeToUserResponse(const SendChallengeToUserResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.SendChallengeToUserResponse) +} + +void SendChallengeToUserResponse::SharedCtor() { + _cached_size_ = 0; + id_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +SendChallengeToUserResponse::~SendChallengeToUserResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.SendChallengeToUserResponse) + SharedDtor(); +} + +void SendChallengeToUserResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void SendChallengeToUserResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SendChallengeToUserResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SendChallengeToUserResponse_descriptor_; +} + +const SendChallengeToUserResponse& SendChallengeToUserResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto(); + return *default_instance_; +} + +SendChallengeToUserResponse* SendChallengeToUserResponse::default_instance_ = NULL; + +SendChallengeToUserResponse* SendChallengeToUserResponse::New() const { + return new SendChallengeToUserResponse; +} + +void SendChallengeToUserResponse::Clear() { + id_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool SendChallengeToUserResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.SendChallengeToUserResponse) + 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 id = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &id_))); + set_has_id(); + } 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:bgs.protocol.challenge.v1.SendChallengeToUserResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.SendChallengeToUserResponse) + return false; +#undef DO_ +} + +void SendChallengeToUserResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.SendChallengeToUserResponse) + // optional uint32 id = 1; + if (has_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.SendChallengeToUserResponse) +} + +::google::protobuf::uint8* SendChallengeToUserResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.SendChallengeToUserResponse) + // optional uint32 id = 1; + if (has_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.SendChallengeToUserResponse) + return target; +} + +int SendChallengeToUserResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional uint32 id = 1; + if (has_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void SendChallengeToUserResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const SendChallengeToUserResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void SendChallengeToUserResponse::MergeFrom(const SendChallengeToUserResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_id()) { + set_id(from.id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void SendChallengeToUserResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SendChallengeToUserResponse::CopyFrom(const SendChallengeToUserResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SendChallengeToUserResponse::IsInitialized() const { + + return true; +} + +void SendChallengeToUserResponse::Swap(SendChallengeToUserResponse* other) { + if (other != this) { + std::swap(id_, other->id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata SendChallengeToUserResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SendChallengeToUserResponse_descriptor_; + metadata.reflection = SendChallengeToUserResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ChallengeUserRequest::kChallengesFieldNumber; +const int ChallengeUserRequest::kContextFieldNumber; +const int ChallengeUserRequest::kIdFieldNumber; +const int ChallengeUserRequest::kDeadlineFieldNumber; +const int ChallengeUserRequest::kAttributesFieldNumber; +const int ChallengeUserRequest::kGameAccountIdFieldNumber; +#endif // !_MSC_VER + +ChallengeUserRequest::ChallengeUserRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengeUserRequest) +} + +void ChallengeUserRequest::InitAsDefaultInstance() { + game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +ChallengeUserRequest::ChallengeUserRequest(const ChallengeUserRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengeUserRequest) +} + +void ChallengeUserRequest::SharedCtor() { + _cached_size_ = 0; + context_ = 0u; + id_ = 0u; + deadline_ = GOOGLE_ULONGLONG(0); + game_account_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ChallengeUserRequest::~ChallengeUserRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengeUserRequest) + SharedDtor(); +} + +void ChallengeUserRequest::SharedDtor() { + if (this != default_instance_) { + delete game_account_id_; + } +} + +void ChallengeUserRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ChallengeUserRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ChallengeUserRequest_descriptor_; +} + +const ChallengeUserRequest& ChallengeUserRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto(); + return *default_instance_; +} + +ChallengeUserRequest* ChallengeUserRequest::default_instance_ = NULL; + +ChallengeUserRequest* ChallengeUserRequest::New() const { + return new ChallengeUserRequest; +} + +void ChallengeUserRequest::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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] & 46) { + ZR_(context_, deadline_); + if (has_game_account_id()) { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + challenges_.Clear(); + attributes_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ChallengeUserRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengeUserRequest) + 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 .bgs.protocol.challenge.v1.Challenge challenges = 1; + case 1: { + if (tag == 10) { + parse_challenges: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_challenges())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_challenges; + if (input->ExpectTag(21)) goto parse_context; + break; + } + + // required fixed32 context = 2; + case 2: { + if (tag == 21) { + parse_context: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &context_))); + set_has_context(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_id; + break; + } + + // optional uint32 id = 3; + case 3: { + if (tag == 24) { + parse_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &id_))); + set_has_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_deadline; + break; + } + + // optional uint64 deadline = 4; + case 4: { + if (tag == 32) { + parse_deadline: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &deadline_))); + set_has_deadline(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_attributes; + break; + } + + // repeated .bgs.protocol.Attribute attributes = 5; + case 5: { + if (tag == 42) { + parse_attributes: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_attributes())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_attributes; + if (input->ExpectTag(50)) goto parse_game_account_id; + break; + } + + // optional .bgs.protocol.EntityId game_account_id = 6; + case 6: { + if (tag == 50) { + parse_game_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account_id())); + } 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:bgs.protocol.challenge.v1.ChallengeUserRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengeUserRequest) + return false; +#undef DO_ +} + +void ChallengeUserRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengeUserRequest) + // repeated .bgs.protocol.challenge.v1.Challenge challenges = 1; + for (int i = 0; i < this->challenges_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->challenges(i), output); + } + + // required fixed32 context = 2; + if (has_context()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->context(), output); + } + + // optional uint32 id = 3; + if (has_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->id(), output); + } + + // optional uint64 deadline = 4; + if (has_deadline()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->deadline(), output); + } + + // repeated .bgs.protocol.Attribute attributes = 5; + for (int i = 0; i < this->attributes_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, this->attributes(i), output); + } + + // optional .bgs.protocol.EntityId game_account_id = 6; + if (has_game_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, this->game_account_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengeUserRequest) +} + +::google::protobuf::uint8* ChallengeUserRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengeUserRequest) + // repeated .bgs.protocol.challenge.v1.Challenge challenges = 1; + for (int i = 0; i < this->challenges_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->challenges(i), target); + } + + // required fixed32 context = 2; + if (has_context()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->context(), target); + } + + // optional uint32 id = 3; + if (has_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->id(), target); + } + + // optional uint64 deadline = 4; + if (has_deadline()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->deadline(), target); + } + + // repeated .bgs.protocol.Attribute attributes = 5; + for (int i = 0; i < this->attributes_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 5, this->attributes(i), target); + } + + // optional .bgs.protocol.EntityId game_account_id = 6; + if (has_game_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 6, this->game_account_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengeUserRequest) + return target; +} + +int ChallengeUserRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) { + // required fixed32 context = 2; + if (has_context()) { + total_size += 1 + 4; + } + + // optional uint32 id = 3; + if (has_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->id()); + } + + // optional uint64 deadline = 4; + if (has_deadline()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->deadline()); + } + + // optional .bgs.protocol.EntityId game_account_id = 6; + if (has_game_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account_id()); + } + + } + // repeated .bgs.protocol.challenge.v1.Challenge challenges = 1; + total_size += 1 * this->challenges_size(); + for (int i = 0; i < this->challenges_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->challenges(i)); + } + + // repeated .bgs.protocol.Attribute attributes = 5; + total_size += 1 * this->attributes_size(); + for (int i = 0; i < this->attributes_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->attributes(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 ChallengeUserRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ChallengeUserRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ChallengeUserRequest::MergeFrom(const ChallengeUserRequest& from) { + GOOGLE_CHECK_NE(&from, this); + challenges_.MergeFrom(from.challenges_); + attributes_.MergeFrom(from.attributes_); + if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) { + if (from.has_context()) { + set_context(from.context()); + } + if (from.has_id()) { + set_id(from.id()); + } + if (from.has_deadline()) { + set_deadline(from.deadline()); + } + if (from.has_game_account_id()) { + mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ChallengeUserRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ChallengeUserRequest::CopyFrom(const ChallengeUserRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ChallengeUserRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false; + + if (!::google::protobuf::internal::AllAreInitialized(this->challenges())) return false; + if (!::google::protobuf::internal::AllAreInitialized(this->attributes())) return false; + if (has_game_account_id()) { + if (!this->game_account_id().IsInitialized()) return false; + } + return true; +} + +void ChallengeUserRequest::Swap(ChallengeUserRequest* other) { + if (other != this) { + challenges_.Swap(&other->challenges_); + std::swap(context_, other->context_); + std::swap(id_, other->id_); + std::swap(deadline_, other->deadline_); + attributes_.Swap(&other->attributes_); + std::swap(game_account_id_, other->game_account_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata ChallengeUserRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ChallengeUserRequest_descriptor_; + metadata.reflection = ChallengeUserRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ChallengeResultRequest::kIdFieldNumber; +const int ChallengeResultRequest::kTypeFieldNumber; +const int ChallengeResultRequest::kErrorIdFieldNumber; +const int ChallengeResultRequest::kAnswerFieldNumber; +#endif // !_MSC_VER + +ChallengeResultRequest::ChallengeResultRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengeResultRequest) +} + +void ChallengeResultRequest::InitAsDefaultInstance() { +} + +ChallengeResultRequest::ChallengeResultRequest(const ChallengeResultRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengeResultRequest) +} + +void ChallengeResultRequest::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + id_ = 0u; + type_ = 0u; + error_id_ = 0u; + answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ChallengeResultRequest::~ChallengeResultRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengeResultRequest) + SharedDtor(); +} + +void ChallengeResultRequest::SharedDtor() { + if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete answer_; + } + if (this != default_instance_) { + } +} + +void ChallengeResultRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ChallengeResultRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ChallengeResultRequest_descriptor_; +} + +const ChallengeResultRequest& ChallengeResultRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto(); + return *default_instance_; +} + +ChallengeResultRequest* ChallengeResultRequest::default_instance_ = NULL; + +ChallengeResultRequest* ChallengeResultRequest::New() const { + return new ChallengeResultRequest; +} + +void ChallengeResultRequest::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(id_, type_); + error_id_ = 0u; + if (has_answer()) { + if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + answer_->clear(); + } + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ChallengeResultRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengeResultRequest) + 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 id = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &id_))); + set_has_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(21)) goto parse_type; + break; + } + + // optional fixed32 type = 2; + case 2: { + if (tag == 21) { + parse_type: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &type_))); + set_has_type(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_error_id; + break; + } + + // optional uint32 error_id = 3; + case 3: { + if (tag == 24) { + parse_error_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &error_id_))); + set_has_error_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_answer; + break; + } + + // optional bytes answer = 4; + case 4: { + if (tag == 34) { + parse_answer: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_answer())); + } 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:bgs.protocol.challenge.v1.ChallengeResultRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengeResultRequest) + return false; +#undef DO_ +} + +void ChallengeResultRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengeResultRequest) + // optional uint32 id = 1; + if (has_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->id(), output); + } + + // optional fixed32 type = 2; + if (has_type()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->type(), output); + } + + // optional uint32 error_id = 3; + if (has_error_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->error_id(), output); + } + + // optional bytes answer = 4; + if (has_answer()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 4, this->answer(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengeResultRequest) +} + +::google::protobuf::uint8* ChallengeResultRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengeResultRequest) + // optional uint32 id = 1; + if (has_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->id(), target); + } + + // optional fixed32 type = 2; + if (has_type()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->type(), target); + } + + // optional uint32 error_id = 3; + if (has_error_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->error_id(), target); + } + + // optional bytes answer = 4; + if (has_answer()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 4, this->answer(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengeResultRequest) + return target; +} + +int ChallengeResultRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional uint32 id = 1; + if (has_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->id()); + } + + // optional fixed32 type = 2; + if (has_type()) { + total_size += 1 + 4; + } + + // optional uint32 error_id = 3; + if (has_error_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->error_id()); + } + + // optional bytes answer = 4; + if (has_answer()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->answer()); + } + + } + 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 ChallengeResultRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ChallengeResultRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ChallengeResultRequest::MergeFrom(const ChallengeResultRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_id()) { + set_id(from.id()); + } + if (from.has_type()) { + set_type(from.type()); + } + if (from.has_error_id()) { + set_error_id(from.error_id()); + } + if (from.has_answer()) { + set_answer(from.answer()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ChallengeResultRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ChallengeResultRequest::CopyFrom(const ChallengeResultRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ChallengeResultRequest::IsInitialized() const { + + return true; +} + +void ChallengeResultRequest::Swap(ChallengeResultRequest* other) { + if (other != this) { + std::swap(id_, other->id_); + std::swap(type_, other->type_); + std::swap(error_id_, other->error_id_); + std::swap(answer_, other->answer_); + 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 ChallengeResultRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ChallengeResultRequest_descriptor_; + metadata.reflection = ChallengeResultRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ChallengeExternalRequest::kRequestTokenFieldNumber; +const int ChallengeExternalRequest::kPayloadTypeFieldNumber; +const int ChallengeExternalRequest::kPayloadFieldNumber; +#endif // !_MSC_VER + +ChallengeExternalRequest::ChallengeExternalRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengeExternalRequest) +} + +void ChallengeExternalRequest::InitAsDefaultInstance() { +} + +ChallengeExternalRequest::ChallengeExternalRequest(const ChallengeExternalRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengeExternalRequest) +} + +void ChallengeExternalRequest::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + request_token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + payload_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + payload_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ChallengeExternalRequest::~ChallengeExternalRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengeExternalRequest) + SharedDtor(); +} + +void ChallengeExternalRequest::SharedDtor() { + if (request_token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete request_token_; + } + if (payload_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete payload_type_; + } + if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete payload_; + } + if (this != default_instance_) { + } +} + +void ChallengeExternalRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ChallengeExternalRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ChallengeExternalRequest_descriptor_; +} + +const ChallengeExternalRequest& ChallengeExternalRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto(); + return *default_instance_; +} + +ChallengeExternalRequest* ChallengeExternalRequest::default_instance_ = NULL; + +ChallengeExternalRequest* ChallengeExternalRequest::New() const { + return new ChallengeExternalRequest; +} + +void ChallengeExternalRequest::Clear() { + if (_has_bits_[0 / 32] & 7) { + if (has_request_token()) { + if (request_token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + request_token_->clear(); + } + } + if (has_payload_type()) { + if (payload_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + payload_type_->clear(); + } + } + if (has_payload()) { + if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + payload_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ChallengeExternalRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengeExternalRequest) + 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 request_token = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_request_token())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->request_token().data(), this->request_token().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "request_token"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_payload_type; + break; + } + + // optional string payload_type = 2; + case 2: { + if (tag == 18) { + parse_payload_type: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_payload_type())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->payload_type().data(), this->payload_type().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "payload_type"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_payload; + break; + } + + // optional bytes payload = 3; + case 3: { + if (tag == 26) { + parse_payload: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_payload())); + } 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:bgs.protocol.challenge.v1.ChallengeExternalRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengeExternalRequest) + return false; +#undef DO_ +} + +void ChallengeExternalRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengeExternalRequest) + // optional string request_token = 1; + if (has_request_token()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->request_token().data(), this->request_token().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "request_token"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->request_token(), output); + } + + // optional string payload_type = 2; + if (has_payload_type()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->payload_type().data(), this->payload_type().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "payload_type"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->payload_type(), output); + } + + // optional bytes payload = 3; + if (has_payload()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 3, this->payload(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengeExternalRequest) +} + +::google::protobuf::uint8* ChallengeExternalRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengeExternalRequest) + // optional string request_token = 1; + if (has_request_token()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->request_token().data(), this->request_token().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "request_token"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->request_token(), target); + } + + // optional string payload_type = 2; + if (has_payload_type()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->payload_type().data(), this->payload_type().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "payload_type"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->payload_type(), target); + } + + // optional bytes payload = 3; + if (has_payload()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 3, this->payload(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengeExternalRequest) + return target; +} + +int ChallengeExternalRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional string request_token = 1; + if (has_request_token()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->request_token()); + } + + // optional string payload_type = 2; + if (has_payload_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->payload_type()); + } + + // optional bytes payload = 3; + if (has_payload()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->payload()); + } + + } + 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 ChallengeExternalRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ChallengeExternalRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ChallengeExternalRequest::MergeFrom(const ChallengeExternalRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_request_token()) { + set_request_token(from.request_token()); + } + if (from.has_payload_type()) { + set_payload_type(from.payload_type()); + } + if (from.has_payload()) { + set_payload(from.payload()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ChallengeExternalRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ChallengeExternalRequest::CopyFrom(const ChallengeExternalRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ChallengeExternalRequest::IsInitialized() const { + + return true; +} + +void ChallengeExternalRequest::Swap(ChallengeExternalRequest* other) { + if (other != this) { + std::swap(request_token_, other->request_token_); + std::swap(payload_type_, other->payload_type_); + std::swap(payload_, other->payload_); + 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 ChallengeExternalRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ChallengeExternalRequest_descriptor_; + metadata.reflection = ChallengeExternalRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ChallengeExternalResult::kRequestTokenFieldNumber; +const int ChallengeExternalResult::kPassedFieldNumber; +#endif // !_MSC_VER + +ChallengeExternalResult::ChallengeExternalResult() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengeExternalResult) +} + +void ChallengeExternalResult::InitAsDefaultInstance() { +} + +ChallengeExternalResult::ChallengeExternalResult(const ChallengeExternalResult& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengeExternalResult) +} + +void ChallengeExternalResult::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + request_token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + passed_ = true; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ChallengeExternalResult::~ChallengeExternalResult() { + // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengeExternalResult) + SharedDtor(); +} + +void ChallengeExternalResult::SharedDtor() { + if (request_token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete request_token_; + } + if (this != default_instance_) { + } +} + +void ChallengeExternalResult::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ChallengeExternalResult::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ChallengeExternalResult_descriptor_; +} + +const ChallengeExternalResult& ChallengeExternalResult::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto(); + return *default_instance_; +} + +ChallengeExternalResult* ChallengeExternalResult::default_instance_ = NULL; + +ChallengeExternalResult* ChallengeExternalResult::New() const { + return new ChallengeExternalResult; +} + +void ChallengeExternalResult::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_request_token()) { + if (request_token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + request_token_->clear(); + } + } + passed_ = true; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ChallengeExternalResult::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengeExternalResult) + 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 request_token = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_request_token())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->request_token().data(), this->request_token().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "request_token"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_passed; + break; + } + + // optional bool passed = 2 [default = true]; + case 2: { + if (tag == 16) { + parse_passed: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &passed_))); + set_has_passed(); + } 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:bgs.protocol.challenge.v1.ChallengeExternalResult) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengeExternalResult) + return false; +#undef DO_ +} + +void ChallengeExternalResult::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengeExternalResult) + // optional string request_token = 1; + if (has_request_token()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->request_token().data(), this->request_token().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "request_token"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->request_token(), output); + } + + // optional bool passed = 2 [default = true]; + if (has_passed()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->passed(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengeExternalResult) +} + +::google::protobuf::uint8* ChallengeExternalResult::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengeExternalResult) + // optional string request_token = 1; + if (has_request_token()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->request_token().data(), this->request_token().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "request_token"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->request_token(), target); + } + + // optional bool passed = 2 [default = true]; + if (has_passed()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->passed(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengeExternalResult) + return target; +} + +int ChallengeExternalResult::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional string request_token = 1; + if (has_request_token()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->request_token()); + } + + // optional bool passed = 2 [default = true]; + if (has_passed()) { + 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 ChallengeExternalResult::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ChallengeExternalResult* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ChallengeExternalResult::MergeFrom(const ChallengeExternalResult& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_request_token()) { + set_request_token(from.request_token()); + } + if (from.has_passed()) { + set_passed(from.passed()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ChallengeExternalResult::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ChallengeExternalResult::CopyFrom(const ChallengeExternalResult& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ChallengeExternalResult::IsInitialized() const { + + return true; +} + +void ChallengeExternalResult::Swap(ChallengeExternalResult* other) { + if (other != this) { + std::swap(request_token_, other->request_token_); + std::swap(passed_, other->passed_); + 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 ChallengeExternalResult::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ChallengeExternalResult_descriptor_; + metadata.reflection = ChallengeExternalResult_reflection_; + return metadata; +} + + +// =================================================================== + +google::protobuf::ServiceDescriptor const* ChallengeService::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ChallengeService_descriptor_; +} + +void ChallengeService::ChallengePicked(::bgs::protocol::challenge::v1::ChallengePickedRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChallengeService.ChallengePicked(bgs.protocol.challenge.v1.ChallengePickedRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 1, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::challenge::v1::ChallengePickedResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void ChallengeService::ChallengeAnswered(::bgs::protocol::challenge::v1::ChallengeAnsweredRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChallengeService.ChallengeAnswered(bgs.protocol.challenge.v1.ChallengeAnsweredRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 2, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::challenge::v1::ChallengeAnsweredResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void ChallengeService::ChallengeCancelled(::bgs::protocol::challenge::v1::ChallengeCancelledRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChallengeService.ChallengeCancelled(bgs.protocol.challenge.v1.ChallengeCancelledRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 3, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void ChallengeService::SendChallengeToUser(::bgs::protocol::challenge::v1::SendChallengeToUserRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChallengeService.SendChallengeToUser(bgs.protocol.challenge.v1.SendChallengeToUserRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 4, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::challenge::v1::SendChallengeToUserResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void ChallengeService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) { + switch(methodId) { + case 1: { + ::bgs::protocol::challenge::v1::ChallengePickedRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChallengeService.ChallengePicked server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::challenge::v1::ChallengePickedResponse response; + uint32 status = HandleChallengePicked(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeService.ChallengePicked(bgs.protocol.challenge.v1.ChallengePickedRequest{ %s }) returned bgs.protocol.challenge.v1.ChallengePickedResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 1, token, &response); + else + SendResponse(service_hash_, 1, token, status); + break; + } + case 2: { + ::bgs::protocol::challenge::v1::ChallengeAnsweredRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChallengeService.ChallengeAnswered server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::challenge::v1::ChallengeAnsweredResponse response; + uint32 status = HandleChallengeAnswered(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeService.ChallengeAnswered(bgs.protocol.challenge.v1.ChallengeAnsweredRequest{ %s }) returned bgs.protocol.challenge.v1.ChallengeAnsweredResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 2, token, &response); + else + SendResponse(service_hash_, 2, token, status); + break; + } + case 3: { + ::bgs::protocol::challenge::v1::ChallengeCancelledRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChallengeService.ChallengeCancelled server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleChallengeCancelled(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeService.ChallengeCancelled(bgs.protocol.challenge.v1.ChallengeCancelledRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 3, token, &response); + else + SendResponse(service_hash_, 3, token, status); + break; + } + case 4: { + ::bgs::protocol::challenge::v1::SendChallengeToUserRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChallengeService.SendChallengeToUser server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::challenge::v1::SendChallengeToUserResponse response; + uint32 status = HandleSendChallengeToUser(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeService.SendChallengeToUser(bgs.protocol.challenge.v1.SendChallengeToUserRequest{ %s }) returned bgs.protocol.challenge.v1.SendChallengeToUserResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 4, token, &response); + else + SendResponse(service_hash_, 4, token, status); + break; + } + default: + TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId); + SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD); + break; + } +} + +uint32 ChallengeService::HandleChallengePicked(::bgs::protocol::challenge::v1::ChallengePickedRequest const* request, ::bgs::protocol::challenge::v1::ChallengePickedResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChallengeService.ChallengePicked({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ChallengeService::HandleChallengeAnswered(::bgs::protocol::challenge::v1::ChallengeAnsweredRequest const* request, ::bgs::protocol::challenge::v1::ChallengeAnsweredResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChallengeService.ChallengeAnswered({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ChallengeService::HandleChallengeCancelled(::bgs::protocol::challenge::v1::ChallengeCancelledRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChallengeService.ChallengeCancelled({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ChallengeService::HandleSendChallengeToUser(::bgs::protocol::challenge::v1::SendChallengeToUserRequest const* request, ::bgs::protocol::challenge::v1::SendChallengeToUserResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChallengeService.SendChallengeToUser({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +// =================================================================== + +google::protobuf::ServiceDescriptor const* ChallengeListener::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ChallengeListener_descriptor_; +} + +void ChallengeListener::OnChallengeUser(::bgs::protocol::challenge::v1::ChallengeUserRequest const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChallengeListener.OnChallengeUser(bgs.protocol.challenge.v1.ChallengeUserRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 1, request); +} + +void ChallengeListener::OnChallengeResult(::bgs::protocol::challenge::v1::ChallengeResultRequest const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChallengeListener.OnChallengeResult(bgs.protocol.challenge.v1.ChallengeResultRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 2, request); +} + +void ChallengeListener::OnExternalChallenge(::bgs::protocol::challenge::v1::ChallengeExternalRequest const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChallengeListener.OnExternalChallenge(bgs.protocol.challenge.v1.ChallengeExternalRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 3, request); +} + +void ChallengeListener::OnExternalChallengeResult(::bgs::protocol::challenge::v1::ChallengeExternalResult const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChallengeListener.OnExternalChallengeResult(bgs.protocol.challenge.v1.ChallengeExternalResult{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 4, request); +} + +void ChallengeListener::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) { + switch(methodId) { + case 1: { + ::bgs::protocol::challenge::v1::ChallengeUserRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChallengeListener.OnChallengeUser server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnChallengeUser(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeListener.OnChallengeUser(bgs.protocol.challenge.v1.ChallengeUserRequest{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 1, token, status); + break; + } + case 2: { + ::bgs::protocol::challenge::v1::ChallengeResultRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChallengeListener.OnChallengeResult server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnChallengeResult(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeListener.OnChallengeResult(bgs.protocol.challenge.v1.ChallengeResultRequest{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 2, token, status); + break; + } + case 3: { + ::bgs::protocol::challenge::v1::ChallengeExternalRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChallengeListener.OnExternalChallenge server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnExternalChallenge(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeListener.OnExternalChallenge(bgs.protocol.challenge.v1.ChallengeExternalRequest{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 3, token, status); + break; + } + case 4: { + ::bgs::protocol::challenge::v1::ChallengeExternalResult request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChallengeListener.OnExternalChallengeResult server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnExternalChallengeResult(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeListener.OnExternalChallengeResult(bgs.protocol.challenge.v1.ChallengeExternalResult{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 4, token, status); + break; + } + default: + TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId); + SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD); + break; + } +} + +uint32 ChallengeListener::HandleOnChallengeUser(::bgs::protocol::challenge::v1::ChallengeUserRequest const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChallengeListener.OnChallengeUser({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ChallengeListener::HandleOnChallengeResult(::bgs::protocol::challenge::v1::ChallengeResultRequest const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChallengeListener.OnChallengeResult({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ChallengeListener::HandleOnExternalChallenge(::bgs::protocol::challenge::v1::ChallengeExternalRequest const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChallengeListener.OnExternalChallenge({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ChallengeListener::HandleOnExternalChallengeResult(::bgs::protocol::challenge::v1::ChallengeExternalResult const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChallengeListener.OnExternalChallengeResult({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace challenge +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/challenge_service.pb.h b/src/server/proto/Client/challenge_service.pb.h new file mode 100644 index 00000000000..0451375d46d --- /dev/null +++ b/src/server/proto/Client/challenge_service.pb.h @@ -0,0 +1,3113 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: challenge_service.proto + +#ifndef PROTOBUF_challenge_5fservice_2eproto__INCLUDED +#define PROTOBUF_challenge_5fservice_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include "attribute_types.pb.h" +#include "entity_types.pb.h" +#include "rpc_types.pb.h" +#include "ServiceBase.h" +#include "MessageBuffer.h" +#include +#include +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { +namespace challenge { +namespace v1 { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto(); +void protobuf_AssignDesc_challenge_5fservice_2eproto(); +void protobuf_ShutdownFile_challenge_5fservice_2eproto(); + +class Challenge; +class ChallengePickedRequest; +class ChallengePickedResponse; +class ChallengeAnsweredRequest; +class ChallengeAnsweredResponse; +class ChallengeCancelledRequest; +class SendChallengeToUserRequest; +class SendChallengeToUserResponse; +class ChallengeUserRequest; +class ChallengeResultRequest; +class ChallengeExternalRequest; +class ChallengeExternalResult; + +// =================================================================== + +class TC_SHARED_API Challenge : public ::google::protobuf::Message { + public: + Challenge(); + virtual ~Challenge(); + + Challenge(const Challenge& from); + + inline Challenge& operator=(const Challenge& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Challenge& default_instance(); + + void Swap(Challenge* other); + + // implements Message ---------------------------------------------- + + Challenge* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Challenge& from); + void MergeFrom(const Challenge& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed32 type = 1; + inline bool has_type() const; + inline void clear_type(); + static const int kTypeFieldNumber = 1; + inline ::google::protobuf::uint32 type() const; + inline void set_type(::google::protobuf::uint32 value); + + // optional string info = 2; + inline bool has_info() const; + inline void clear_info(); + static const int kInfoFieldNumber = 2; + inline const ::std::string& info() const; + inline void set_info(const ::std::string& value); + inline void set_info(const char* value); + inline void set_info(const char* value, size_t size); + inline ::std::string* mutable_info(); + inline ::std::string* release_info(); + inline void set_allocated_info(::std::string* info); + + // optional string answer = 3; + inline bool has_answer() const; + inline void clear_answer(); + static const int kAnswerFieldNumber = 3; + inline const ::std::string& answer() const; + inline void set_answer(const ::std::string& value); + inline void set_answer(const char* value); + inline void set_answer(const char* value, size_t size); + inline ::std::string* mutable_answer(); + inline ::std::string* release_answer(); + inline void set_allocated_answer(::std::string* answer); + + // optional uint32 retries = 4; + inline bool has_retries() const; + inline void clear_retries(); + static const int kRetriesFieldNumber = 4; + inline ::google::protobuf::uint32 retries() const; + inline void set_retries(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.Challenge) + private: + inline void set_has_type(); + inline void clear_has_type(); + inline void set_has_info(); + inline void clear_has_info(); + inline void set_has_answer(); + inline void clear_has_answer(); + inline void set_has_retries(); + inline void clear_has_retries(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* info_; + ::google::protobuf::uint32 type_; + ::google::protobuf::uint32 retries_; + ::std::string* answer_; + friend void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto(); + friend void protobuf_AssignDesc_challenge_5fservice_2eproto(); + friend void protobuf_ShutdownFile_challenge_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static Challenge* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ChallengePickedRequest : public ::google::protobuf::Message { + public: + ChallengePickedRequest(); + virtual ~ChallengePickedRequest(); + + ChallengePickedRequest(const ChallengePickedRequest& from); + + inline ChallengePickedRequest& operator=(const ChallengePickedRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ChallengePickedRequest& default_instance(); + + void Swap(ChallengePickedRequest* other); + + // implements Message ---------------------------------------------- + + ChallengePickedRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ChallengePickedRequest& from); + void MergeFrom(const ChallengePickedRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed32 challenge = 1; + inline bool has_challenge() const; + inline void clear_challenge(); + static const int kChallengeFieldNumber = 1; + inline ::google::protobuf::uint32 challenge() const; + inline void set_challenge(::google::protobuf::uint32 value); + + // optional uint32 id = 2; + inline bool has_id() const; + inline void clear_id(); + static const int kIdFieldNumber = 2; + inline ::google::protobuf::uint32 id() const; + inline void set_id(::google::protobuf::uint32 value); + + // optional bool new_challenge_protocol = 3 [default = false]; + inline bool has_new_challenge_protocol() const; + inline void clear_new_challenge_protocol(); + static const int kNewChallengeProtocolFieldNumber = 3; + inline bool new_challenge_protocol() const; + inline void set_new_challenge_protocol(bool value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.ChallengePickedRequest) + private: + inline void set_has_challenge(); + inline void clear_has_challenge(); + inline void set_has_id(); + inline void clear_has_id(); + inline void set_has_new_challenge_protocol(); + inline void clear_has_new_challenge_protocol(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 challenge_; + ::google::protobuf::uint32 id_; + bool new_challenge_protocol_; + friend void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto(); + friend void protobuf_AssignDesc_challenge_5fservice_2eproto(); + friend void protobuf_ShutdownFile_challenge_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ChallengePickedRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ChallengePickedResponse : public ::google::protobuf::Message { + public: + ChallengePickedResponse(); + virtual ~ChallengePickedResponse(); + + ChallengePickedResponse(const ChallengePickedResponse& from); + + inline ChallengePickedResponse& operator=(const ChallengePickedResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ChallengePickedResponse& default_instance(); + + void Swap(ChallengePickedResponse* other); + + // implements Message ---------------------------------------------- + + ChallengePickedResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ChallengePickedResponse& from); + void MergeFrom(const ChallengePickedResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional bytes data = 1; + inline bool has_data() const; + inline void clear_data(); + static const int kDataFieldNumber = 1; + inline const ::std::string& data() const; + inline void set_data(const ::std::string& value); + inline void set_data(const char* value); + inline void set_data(const void* value, size_t size); + inline ::std::string* mutable_data(); + inline ::std::string* release_data(); + inline void set_allocated_data(::std::string* data); + + // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.ChallengePickedResponse) + private: + inline void set_has_data(); + inline void clear_has_data(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* data_; + friend void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto(); + friend void protobuf_AssignDesc_challenge_5fservice_2eproto(); + friend void protobuf_ShutdownFile_challenge_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ChallengePickedResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ChallengeAnsweredRequest : public ::google::protobuf::Message { + public: + ChallengeAnsweredRequest(); + virtual ~ChallengeAnsweredRequest(); + + ChallengeAnsweredRequest(const ChallengeAnsweredRequest& from); + + inline ChallengeAnsweredRequest& operator=(const ChallengeAnsweredRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ChallengeAnsweredRequest& default_instance(); + + void Swap(ChallengeAnsweredRequest* other); + + // implements Message ---------------------------------------------- + + ChallengeAnsweredRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ChallengeAnsweredRequest& from); + void MergeFrom(const ChallengeAnsweredRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string answer = 1; + inline bool has_answer() const; + inline void clear_answer(); + static const int kAnswerFieldNumber = 1; + inline const ::std::string& answer() const; + inline void set_answer(const ::std::string& value); + inline void set_answer(const char* value); + inline void set_answer(const char* value, size_t size); + inline ::std::string* mutable_answer(); + inline ::std::string* release_answer(); + inline void set_allocated_answer(::std::string* answer); + + // optional bytes data = 2; + inline bool has_data() const; + inline void clear_data(); + static const int kDataFieldNumber = 2; + inline const ::std::string& data() const; + inline void set_data(const ::std::string& value); + inline void set_data(const char* value); + inline void set_data(const void* value, size_t size); + inline ::std::string* mutable_data(); + inline ::std::string* release_data(); + inline void set_allocated_data(::std::string* data); + + // optional uint32 id = 3; + inline bool has_id() const; + inline void clear_id(); + static const int kIdFieldNumber = 3; + inline ::google::protobuf::uint32 id() const; + inline void set_id(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.ChallengeAnsweredRequest) + private: + inline void set_has_answer(); + inline void clear_has_answer(); + inline void set_has_data(); + inline void clear_has_data(); + inline void set_has_id(); + inline void clear_has_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* answer_; + ::std::string* data_; + ::google::protobuf::uint32 id_; + friend void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto(); + friend void protobuf_AssignDesc_challenge_5fservice_2eproto(); + friend void protobuf_ShutdownFile_challenge_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ChallengeAnsweredRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ChallengeAnsweredResponse : public ::google::protobuf::Message { + public: + ChallengeAnsweredResponse(); + virtual ~ChallengeAnsweredResponse(); + + ChallengeAnsweredResponse(const ChallengeAnsweredResponse& from); + + inline ChallengeAnsweredResponse& operator=(const ChallengeAnsweredResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ChallengeAnsweredResponse& default_instance(); + + void Swap(ChallengeAnsweredResponse* other); + + // implements Message ---------------------------------------------- + + ChallengeAnsweredResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ChallengeAnsweredResponse& from); + void MergeFrom(const ChallengeAnsweredResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional bytes data = 1; + inline bool has_data() const; + inline void clear_data(); + static const int kDataFieldNumber = 1; + inline const ::std::string& data() const; + inline void set_data(const ::std::string& value); + inline void set_data(const char* value); + inline void set_data(const void* value, size_t size); + inline ::std::string* mutable_data(); + inline ::std::string* release_data(); + inline void set_allocated_data(::std::string* data); + + // optional bool do_retry = 2; + inline bool has_do_retry() const; + inline void clear_do_retry(); + static const int kDoRetryFieldNumber = 2; + inline bool do_retry() const; + inline void set_do_retry(bool value); + + // optional bool record_not_found = 3; + inline bool has_record_not_found() const; + inline void clear_record_not_found(); + static const int kRecordNotFoundFieldNumber = 3; + inline bool record_not_found() const; + inline void set_record_not_found(bool value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.ChallengeAnsweredResponse) + private: + inline void set_has_data(); + inline void clear_has_data(); + inline void set_has_do_retry(); + inline void clear_has_do_retry(); + inline void set_has_record_not_found(); + inline void clear_has_record_not_found(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* data_; + bool do_retry_; + bool record_not_found_; + friend void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto(); + friend void protobuf_AssignDesc_challenge_5fservice_2eproto(); + friend void protobuf_ShutdownFile_challenge_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ChallengeAnsweredResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ChallengeCancelledRequest : public ::google::protobuf::Message { + public: + ChallengeCancelledRequest(); + virtual ~ChallengeCancelledRequest(); + + ChallengeCancelledRequest(const ChallengeCancelledRequest& from); + + inline ChallengeCancelledRequest& operator=(const ChallengeCancelledRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ChallengeCancelledRequest& default_instance(); + + void Swap(ChallengeCancelledRequest* other); + + // implements Message ---------------------------------------------- + + ChallengeCancelledRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ChallengeCancelledRequest& from); + void MergeFrom(const ChallengeCancelledRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint32 id = 1; + inline bool has_id() const; + inline void clear_id(); + static const int kIdFieldNumber = 1; + inline ::google::protobuf::uint32 id() const; + inline void set_id(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.ChallengeCancelledRequest) + private: + inline void set_has_id(); + inline void clear_has_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 id_; + friend void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto(); + friend void protobuf_AssignDesc_challenge_5fservice_2eproto(); + friend void protobuf_ShutdownFile_challenge_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ChallengeCancelledRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API SendChallengeToUserRequest : public ::google::protobuf::Message { + public: + SendChallengeToUserRequest(); + virtual ~SendChallengeToUserRequest(); + + SendChallengeToUserRequest(const SendChallengeToUserRequest& from); + + inline SendChallengeToUserRequest& operator=(const SendChallengeToUserRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SendChallengeToUserRequest& default_instance(); + + void Swap(SendChallengeToUserRequest* other); + + // implements Message ---------------------------------------------- + + SendChallengeToUserRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SendChallengeToUserRequest& from); + void MergeFrom(const SendChallengeToUserRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.ProcessId peer_id = 1; + inline bool has_peer_id() const; + inline void clear_peer_id(); + static const int kPeerIdFieldNumber = 1; + inline const ::bgs::protocol::ProcessId& peer_id() const; + inline ::bgs::protocol::ProcessId* mutable_peer_id(); + inline ::bgs::protocol::ProcessId* release_peer_id(); + inline void set_allocated_peer_id(::bgs::protocol::ProcessId* peer_id); + + // optional .bgs.protocol.EntityId game_account_id = 2; + inline bool has_game_account_id() const; + inline void clear_game_account_id(); + static const int kGameAccountIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& game_account_id() const; + inline ::bgs::protocol::EntityId* mutable_game_account_id(); + inline ::bgs::protocol::EntityId* release_game_account_id(); + inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id); + + // repeated .bgs.protocol.challenge.v1.Challenge challenges = 3; + inline int challenges_size() const; + inline void clear_challenges(); + static const int kChallengesFieldNumber = 3; + inline const ::bgs::protocol::challenge::v1::Challenge& challenges(int index) const; + inline ::bgs::protocol::challenge::v1::Challenge* mutable_challenges(int index); + inline ::bgs::protocol::challenge::v1::Challenge* add_challenges(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge >& + challenges() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge >* + mutable_challenges(); + + // required fixed32 context = 4; + inline bool has_context() const; + inline void clear_context(); + static const int kContextFieldNumber = 4; + inline ::google::protobuf::uint32 context() const; + inline void set_context(::google::protobuf::uint32 value); + + // optional uint64 timeout = 5; + inline bool has_timeout() const; + inline void clear_timeout(); + static const int kTimeoutFieldNumber = 5; + inline ::google::protobuf::uint64 timeout() const; + inline void set_timeout(::google::protobuf::uint64 value); + + // repeated .bgs.protocol.Attribute attributes = 6; + inline int attributes_size() const; + inline void clear_attributes(); + static const int kAttributesFieldNumber = 6; + inline const ::bgs::protocol::Attribute& attributes(int index) const; + inline ::bgs::protocol::Attribute* mutable_attributes(int index); + inline ::bgs::protocol::Attribute* add_attributes(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& + attributes() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* + mutable_attributes(); + + // optional .bgs.protocol.ProcessId host = 7; + inline bool has_host() const; + inline void clear_host(); + static const int kHostFieldNumber = 7; + inline const ::bgs::protocol::ProcessId& host() const; + inline ::bgs::protocol::ProcessId* mutable_host(); + inline ::bgs::protocol::ProcessId* release_host(); + inline void set_allocated_host(::bgs::protocol::ProcessId* host); + + // optional .bgs.protocol.EntityId account_id = 8; + inline bool has_account_id() const; + inline void clear_account_id(); + static const int kAccountIdFieldNumber = 8; + inline const ::bgs::protocol::EntityId& account_id() const; + inline ::bgs::protocol::EntityId* mutable_account_id(); + inline ::bgs::protocol::EntityId* release_account_id(); + inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id); + + // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.SendChallengeToUserRequest) + private: + inline void set_has_peer_id(); + inline void clear_has_peer_id(); + inline void set_has_game_account_id(); + inline void clear_has_game_account_id(); + inline void set_has_context(); + inline void clear_has_context(); + inline void set_has_timeout(); + inline void clear_has_timeout(); + inline void set_has_host(); + inline void clear_has_host(); + inline void set_has_account_id(); + inline void clear_has_account_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::ProcessId* peer_id_; + ::bgs::protocol::EntityId* game_account_id_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge > challenges_; + ::google::protobuf::uint64 timeout_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attributes_; + ::bgs::protocol::ProcessId* host_; + ::bgs::protocol::EntityId* account_id_; + ::google::protobuf::uint32 context_; + friend void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto(); + friend void protobuf_AssignDesc_challenge_5fservice_2eproto(); + friend void protobuf_ShutdownFile_challenge_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static SendChallengeToUserRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API SendChallengeToUserResponse : public ::google::protobuf::Message { + public: + SendChallengeToUserResponse(); + virtual ~SendChallengeToUserResponse(); + + SendChallengeToUserResponse(const SendChallengeToUserResponse& from); + + inline SendChallengeToUserResponse& operator=(const SendChallengeToUserResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SendChallengeToUserResponse& default_instance(); + + void Swap(SendChallengeToUserResponse* other); + + // implements Message ---------------------------------------------- + + SendChallengeToUserResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SendChallengeToUserResponse& from); + void MergeFrom(const SendChallengeToUserResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint32 id = 1; + inline bool has_id() const; + inline void clear_id(); + static const int kIdFieldNumber = 1; + inline ::google::protobuf::uint32 id() const; + inline void set_id(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.SendChallengeToUserResponse) + private: + inline void set_has_id(); + inline void clear_has_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 id_; + friend void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto(); + friend void protobuf_AssignDesc_challenge_5fservice_2eproto(); + friend void protobuf_ShutdownFile_challenge_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static SendChallengeToUserResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ChallengeUserRequest : public ::google::protobuf::Message { + public: + ChallengeUserRequest(); + virtual ~ChallengeUserRequest(); + + ChallengeUserRequest(const ChallengeUserRequest& from); + + inline ChallengeUserRequest& operator=(const ChallengeUserRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ChallengeUserRequest& default_instance(); + + void Swap(ChallengeUserRequest* other); + + // implements Message ---------------------------------------------- + + ChallengeUserRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ChallengeUserRequest& from); + void MergeFrom(const ChallengeUserRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.challenge.v1.Challenge challenges = 1; + inline int challenges_size() const; + inline void clear_challenges(); + static const int kChallengesFieldNumber = 1; + inline const ::bgs::protocol::challenge::v1::Challenge& challenges(int index) const; + inline ::bgs::protocol::challenge::v1::Challenge* mutable_challenges(int index); + inline ::bgs::protocol::challenge::v1::Challenge* add_challenges(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge >& + challenges() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge >* + mutable_challenges(); + + // required fixed32 context = 2; + inline bool has_context() const; + inline void clear_context(); + static const int kContextFieldNumber = 2; + inline ::google::protobuf::uint32 context() const; + inline void set_context(::google::protobuf::uint32 value); + + // optional uint32 id = 3; + inline bool has_id() const; + inline void clear_id(); + static const int kIdFieldNumber = 3; + inline ::google::protobuf::uint32 id() const; + inline void set_id(::google::protobuf::uint32 value); + + // optional uint64 deadline = 4; + inline bool has_deadline() const; + inline void clear_deadline(); + static const int kDeadlineFieldNumber = 4; + inline ::google::protobuf::uint64 deadline() const; + inline void set_deadline(::google::protobuf::uint64 value); + + // repeated .bgs.protocol.Attribute attributes = 5; + inline int attributes_size() const; + inline void clear_attributes(); + static const int kAttributesFieldNumber = 5; + inline const ::bgs::protocol::Attribute& attributes(int index) const; + inline ::bgs::protocol::Attribute* mutable_attributes(int index); + inline ::bgs::protocol::Attribute* add_attributes(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& + attributes() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* + mutable_attributes(); + + // optional .bgs.protocol.EntityId game_account_id = 6; + inline bool has_game_account_id() const; + inline void clear_game_account_id(); + static const int kGameAccountIdFieldNumber = 6; + inline const ::bgs::protocol::EntityId& game_account_id() const; + inline ::bgs::protocol::EntityId* mutable_game_account_id(); + inline ::bgs::protocol::EntityId* release_game_account_id(); + inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id); + + // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.ChallengeUserRequest) + private: + inline void set_has_context(); + inline void clear_has_context(); + inline void set_has_id(); + inline void clear_has_id(); + inline void set_has_deadline(); + inline void clear_has_deadline(); + inline void set_has_game_account_id(); + inline void clear_has_game_account_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge > challenges_; + ::google::protobuf::uint32 context_; + ::google::protobuf::uint32 id_; + ::google::protobuf::uint64 deadline_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attributes_; + ::bgs::protocol::EntityId* game_account_id_; + friend void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto(); + friend void protobuf_AssignDesc_challenge_5fservice_2eproto(); + friend void protobuf_ShutdownFile_challenge_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ChallengeUserRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ChallengeResultRequest : public ::google::protobuf::Message { + public: + ChallengeResultRequest(); + virtual ~ChallengeResultRequest(); + + ChallengeResultRequest(const ChallengeResultRequest& from); + + inline ChallengeResultRequest& operator=(const ChallengeResultRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ChallengeResultRequest& default_instance(); + + void Swap(ChallengeResultRequest* other); + + // implements Message ---------------------------------------------- + + ChallengeResultRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ChallengeResultRequest& from); + void MergeFrom(const ChallengeResultRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint32 id = 1; + inline bool has_id() const; + inline void clear_id(); + static const int kIdFieldNumber = 1; + inline ::google::protobuf::uint32 id() const; + inline void set_id(::google::protobuf::uint32 value); + + // optional fixed32 type = 2; + inline bool has_type() const; + inline void clear_type(); + static const int kTypeFieldNumber = 2; + inline ::google::protobuf::uint32 type() const; + inline void set_type(::google::protobuf::uint32 value); + + // optional uint32 error_id = 3; + inline bool has_error_id() const; + inline void clear_error_id(); + static const int kErrorIdFieldNumber = 3; + inline ::google::protobuf::uint32 error_id() const; + inline void set_error_id(::google::protobuf::uint32 value); + + // optional bytes answer = 4; + inline bool has_answer() const; + inline void clear_answer(); + static const int kAnswerFieldNumber = 4; + inline const ::std::string& answer() const; + inline void set_answer(const ::std::string& value); + inline void set_answer(const char* value); + inline void set_answer(const void* value, size_t size); + inline ::std::string* mutable_answer(); + inline ::std::string* release_answer(); + inline void set_allocated_answer(::std::string* answer); + + // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.ChallengeResultRequest) + private: + inline void set_has_id(); + inline void clear_has_id(); + inline void set_has_type(); + inline void clear_has_type(); + inline void set_has_error_id(); + inline void clear_has_error_id(); + inline void set_has_answer(); + inline void clear_has_answer(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 id_; + ::google::protobuf::uint32 type_; + ::std::string* answer_; + ::google::protobuf::uint32 error_id_; + friend void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto(); + friend void protobuf_AssignDesc_challenge_5fservice_2eproto(); + friend void protobuf_ShutdownFile_challenge_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ChallengeResultRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ChallengeExternalRequest : public ::google::protobuf::Message { + public: + ChallengeExternalRequest(); + virtual ~ChallengeExternalRequest(); + + ChallengeExternalRequest(const ChallengeExternalRequest& from); + + inline ChallengeExternalRequest& operator=(const ChallengeExternalRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ChallengeExternalRequest& default_instance(); + + void Swap(ChallengeExternalRequest* other); + + // implements Message ---------------------------------------------- + + ChallengeExternalRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ChallengeExternalRequest& from); + void MergeFrom(const ChallengeExternalRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string request_token = 1; + inline bool has_request_token() const; + inline void clear_request_token(); + static const int kRequestTokenFieldNumber = 1; + inline const ::std::string& request_token() const; + inline void set_request_token(const ::std::string& value); + inline void set_request_token(const char* value); + inline void set_request_token(const char* value, size_t size); + inline ::std::string* mutable_request_token(); + inline ::std::string* release_request_token(); + inline void set_allocated_request_token(::std::string* request_token); + + // optional string payload_type = 2; + inline bool has_payload_type() const; + inline void clear_payload_type(); + static const int kPayloadTypeFieldNumber = 2; + inline const ::std::string& payload_type() const; + inline void set_payload_type(const ::std::string& value); + inline void set_payload_type(const char* value); + inline void set_payload_type(const char* value, size_t size); + inline ::std::string* mutable_payload_type(); + inline ::std::string* release_payload_type(); + inline void set_allocated_payload_type(::std::string* payload_type); + + // optional bytes payload = 3; + inline bool has_payload() const; + inline void clear_payload(); + static const int kPayloadFieldNumber = 3; + inline const ::std::string& payload() const; + inline void set_payload(const ::std::string& value); + inline void set_payload(const char* value); + inline void set_payload(const void* value, size_t size); + inline ::std::string* mutable_payload(); + inline ::std::string* release_payload(); + inline void set_allocated_payload(::std::string* payload); + + // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.ChallengeExternalRequest) + private: + inline void set_has_request_token(); + inline void clear_has_request_token(); + inline void set_has_payload_type(); + inline void clear_has_payload_type(); + inline void set_has_payload(); + inline void clear_has_payload(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* request_token_; + ::std::string* payload_type_; + ::std::string* payload_; + friend void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto(); + friend void protobuf_AssignDesc_challenge_5fservice_2eproto(); + friend void protobuf_ShutdownFile_challenge_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ChallengeExternalRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ChallengeExternalResult : public ::google::protobuf::Message { + public: + ChallengeExternalResult(); + virtual ~ChallengeExternalResult(); + + ChallengeExternalResult(const ChallengeExternalResult& from); + + inline ChallengeExternalResult& operator=(const ChallengeExternalResult& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ChallengeExternalResult& default_instance(); + + void Swap(ChallengeExternalResult* other); + + // implements Message ---------------------------------------------- + + ChallengeExternalResult* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ChallengeExternalResult& from); + void MergeFrom(const ChallengeExternalResult& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string request_token = 1; + inline bool has_request_token() const; + inline void clear_request_token(); + static const int kRequestTokenFieldNumber = 1; + inline const ::std::string& request_token() const; + inline void set_request_token(const ::std::string& value); + inline void set_request_token(const char* value); + inline void set_request_token(const char* value, size_t size); + inline ::std::string* mutable_request_token(); + inline ::std::string* release_request_token(); + inline void set_allocated_request_token(::std::string* request_token); + + // optional bool passed = 2 [default = true]; + inline bool has_passed() const; + inline void clear_passed(); + static const int kPassedFieldNumber = 2; + inline bool passed() const; + inline void set_passed(bool value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.ChallengeExternalResult) + private: + inline void set_has_request_token(); + inline void clear_has_request_token(); + inline void set_has_passed(); + inline void clear_has_passed(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* request_token_; + bool passed_; + friend void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto(); + friend void protobuf_AssignDesc_challenge_5fservice_2eproto(); + friend void protobuf_ShutdownFile_challenge_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ChallengeExternalResult* default_instance_; +}; +// =================================================================== + +class TC_SHARED_API ChallengeService : public ServiceBase +{ + public: + + template + explicit ChallengeService(HashSelector) : service_hash_(HashSelector::Result::value) { } + + typedef std::integral_constant OriginalHash; + typedef std::integral_constant NameHash; + + static google::protobuf::ServiceDescriptor const* descriptor(); + + // client methods -------------------------------------------------- + + void ChallengePicked(::bgs::protocol::challenge::v1::ChallengePickedRequest const* request, std::function responseCallback); + void ChallengeAnswered(::bgs::protocol::challenge::v1::ChallengeAnsweredRequest const* request, std::function responseCallback); + void ChallengeCancelled(::bgs::protocol::challenge::v1::ChallengeCancelledRequest const* request, std::function responseCallback); + void SendChallengeToUser(::bgs::protocol::challenge::v1::SendChallengeToUserRequest const* request, std::function responseCallback); + // server methods -------------------------------------------------- + + void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final; + + protected: + virtual uint32 HandleChallengePicked(::bgs::protocol::challenge::v1::ChallengePickedRequest const* request, ::bgs::protocol::challenge::v1::ChallengePickedResponse* response); + virtual uint32 HandleChallengeAnswered(::bgs::protocol::challenge::v1::ChallengeAnsweredRequest const* request, ::bgs::protocol::challenge::v1::ChallengeAnsweredResponse* response); + virtual uint32 HandleChallengeCancelled(::bgs::protocol::challenge::v1::ChallengeCancelledRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleSendChallengeToUser(::bgs::protocol::challenge::v1::SendChallengeToUserRequest const* request, ::bgs::protocol::challenge::v1::SendChallengeToUserResponse* response); + + private: + uint32 service_hash_; + + GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ChallengeService); +}; + +// ------------------------------------------------------------------- + +class TC_SHARED_API ChallengeListener : public ServiceBase +{ + public: + + template + explicit ChallengeListener(HashSelector) : service_hash_(HashSelector::Result::value) { } + + typedef std::integral_constant OriginalHash; + typedef std::integral_constant NameHash; + + static google::protobuf::ServiceDescriptor const* descriptor(); + + // client methods -------------------------------------------------- + + void OnChallengeUser(::bgs::protocol::challenge::v1::ChallengeUserRequest const* request); + void OnChallengeResult(::bgs::protocol::challenge::v1::ChallengeResultRequest const* request); + void OnExternalChallenge(::bgs::protocol::challenge::v1::ChallengeExternalRequest const* request); + void OnExternalChallengeResult(::bgs::protocol::challenge::v1::ChallengeExternalResult const* request); + // server methods -------------------------------------------------- + + void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final; + + protected: + virtual uint32 HandleOnChallengeUser(::bgs::protocol::challenge::v1::ChallengeUserRequest const* request); + virtual uint32 HandleOnChallengeResult(::bgs::protocol::challenge::v1::ChallengeResultRequest const* request); + virtual uint32 HandleOnExternalChallenge(::bgs::protocol::challenge::v1::ChallengeExternalRequest const* request); + virtual uint32 HandleOnExternalChallengeResult(::bgs::protocol::challenge::v1::ChallengeExternalResult const* request); + + private: + uint32 service_hash_; + + GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ChallengeListener); +}; + +// =================================================================== + + +// =================================================================== + +// Challenge + +// required fixed32 type = 1; +inline bool Challenge::has_type() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Challenge::set_has_type() { + _has_bits_[0] |= 0x00000001u; +} +inline void Challenge::clear_has_type() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Challenge::clear_type() { + type_ = 0u; + clear_has_type(); +} +inline ::google::protobuf::uint32 Challenge::type() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.Challenge.type) + return type_; +} +inline void Challenge::set_type(::google::protobuf::uint32 value) { + set_has_type(); + type_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.Challenge.type) +} + +// optional string info = 2; +inline bool Challenge::has_info() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Challenge::set_has_info() { + _has_bits_[0] |= 0x00000002u; +} +inline void Challenge::clear_has_info() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Challenge::clear_info() { + if (info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + info_->clear(); + } + clear_has_info(); +} +inline const ::std::string& Challenge::info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.Challenge.info) + return *info_; +} +inline void Challenge::set_info(const ::std::string& value) { + set_has_info(); + if (info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + info_ = new ::std::string; + } + info_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.Challenge.info) +} +inline void Challenge::set_info(const char* value) { + set_has_info(); + if (info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + info_ = new ::std::string; + } + info_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.Challenge.info) +} +inline void Challenge::set_info(const char* value, size_t size) { + set_has_info(); + if (info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + info_ = new ::std::string; + } + info_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.Challenge.info) +} +inline ::std::string* Challenge::mutable_info() { + set_has_info(); + if (info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + info_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.Challenge.info) + return info_; +} +inline ::std::string* Challenge::release_info() { + clear_has_info(); + if (info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = info_; + info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void Challenge::set_allocated_info(::std::string* info) { + if (info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete info_; + } + if (info) { + set_has_info(); + info_ = info; + } else { + clear_has_info(); + info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.Challenge.info) +} + +// optional string answer = 3; +inline bool Challenge::has_answer() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void Challenge::set_has_answer() { + _has_bits_[0] |= 0x00000004u; +} +inline void Challenge::clear_has_answer() { + _has_bits_[0] &= ~0x00000004u; +} +inline void Challenge::clear_answer() { + if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + answer_->clear(); + } + clear_has_answer(); +} +inline const ::std::string& Challenge::answer() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.Challenge.answer) + return *answer_; +} +inline void Challenge::set_answer(const ::std::string& value) { + set_has_answer(); + if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + answer_ = new ::std::string; + } + answer_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.Challenge.answer) +} +inline void Challenge::set_answer(const char* value) { + set_has_answer(); + if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + answer_ = new ::std::string; + } + answer_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.Challenge.answer) +} +inline void Challenge::set_answer(const char* value, size_t size) { + set_has_answer(); + if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + answer_ = new ::std::string; + } + answer_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.Challenge.answer) +} +inline ::std::string* Challenge::mutable_answer() { + set_has_answer(); + if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + answer_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.Challenge.answer) + return answer_; +} +inline ::std::string* Challenge::release_answer() { + clear_has_answer(); + if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = answer_; + answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void Challenge::set_allocated_answer(::std::string* answer) { + if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete answer_; + } + if (answer) { + set_has_answer(); + answer_ = answer; + } else { + clear_has_answer(); + answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.Challenge.answer) +} + +// optional uint32 retries = 4; +inline bool Challenge::has_retries() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void Challenge::set_has_retries() { + _has_bits_[0] |= 0x00000008u; +} +inline void Challenge::clear_has_retries() { + _has_bits_[0] &= ~0x00000008u; +} +inline void Challenge::clear_retries() { + retries_ = 0u; + clear_has_retries(); +} +inline ::google::protobuf::uint32 Challenge::retries() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.Challenge.retries) + return retries_; +} +inline void Challenge::set_retries(::google::protobuf::uint32 value) { + set_has_retries(); + retries_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.Challenge.retries) +} + +// ------------------------------------------------------------------- + +// ChallengePickedRequest + +// required fixed32 challenge = 1; +inline bool ChallengePickedRequest::has_challenge() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ChallengePickedRequest::set_has_challenge() { + _has_bits_[0] |= 0x00000001u; +} +inline void ChallengePickedRequest::clear_has_challenge() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ChallengePickedRequest::clear_challenge() { + challenge_ = 0u; + clear_has_challenge(); +} +inline ::google::protobuf::uint32 ChallengePickedRequest::challenge() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengePickedRequest.challenge) + return challenge_; +} +inline void ChallengePickedRequest::set_challenge(::google::protobuf::uint32 value) { + set_has_challenge(); + challenge_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengePickedRequest.challenge) +} + +// optional uint32 id = 2; +inline bool ChallengePickedRequest::has_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ChallengePickedRequest::set_has_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void ChallengePickedRequest::clear_has_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ChallengePickedRequest::clear_id() { + id_ = 0u; + clear_has_id(); +} +inline ::google::protobuf::uint32 ChallengePickedRequest::id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengePickedRequest.id) + return id_; +} +inline void ChallengePickedRequest::set_id(::google::protobuf::uint32 value) { + set_has_id(); + id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengePickedRequest.id) +} + +// optional bool new_challenge_protocol = 3 [default = false]; +inline bool ChallengePickedRequest::has_new_challenge_protocol() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ChallengePickedRequest::set_has_new_challenge_protocol() { + _has_bits_[0] |= 0x00000004u; +} +inline void ChallengePickedRequest::clear_has_new_challenge_protocol() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ChallengePickedRequest::clear_new_challenge_protocol() { + new_challenge_protocol_ = false; + clear_has_new_challenge_protocol(); +} +inline bool ChallengePickedRequest::new_challenge_protocol() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengePickedRequest.new_challenge_protocol) + return new_challenge_protocol_; +} +inline void ChallengePickedRequest::set_new_challenge_protocol(bool value) { + set_has_new_challenge_protocol(); + new_challenge_protocol_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengePickedRequest.new_challenge_protocol) +} + +// ------------------------------------------------------------------- + +// ChallengePickedResponse + +// optional bytes data = 1; +inline bool ChallengePickedResponse::has_data() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ChallengePickedResponse::set_has_data() { + _has_bits_[0] |= 0x00000001u; +} +inline void ChallengePickedResponse::clear_has_data() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ChallengePickedResponse::clear_data() { + if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_->clear(); + } + clear_has_data(); +} +inline const ::std::string& ChallengePickedResponse::data() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengePickedResponse.data) + return *data_; +} +inline void ChallengePickedResponse::set_data(const ::std::string& value) { + set_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_ = new ::std::string; + } + data_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengePickedResponse.data) +} +inline void ChallengePickedResponse::set_data(const char* value) { + set_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_ = new ::std::string; + } + data_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.ChallengePickedResponse.data) +} +inline void ChallengePickedResponse::set_data(const void* value, size_t size) { + set_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_ = new ::std::string; + } + data_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.ChallengePickedResponse.data) +} +inline ::std::string* ChallengePickedResponse::mutable_data() { + set_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengePickedResponse.data) + return data_; +} +inline ::std::string* ChallengePickedResponse::release_data() { + clear_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = data_; + data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ChallengePickedResponse::set_allocated_data(::std::string* data) { + if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete data_; + } + if (data) { + set_has_data(); + data_ = data; + } else { + clear_has_data(); + data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.ChallengePickedResponse.data) +} + +// ------------------------------------------------------------------- + +// ChallengeAnsweredRequest + +// required string answer = 1; +inline bool ChallengeAnsweredRequest::has_answer() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ChallengeAnsweredRequest::set_has_answer() { + _has_bits_[0] |= 0x00000001u; +} +inline void ChallengeAnsweredRequest::clear_has_answer() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ChallengeAnsweredRequest::clear_answer() { + if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + answer_->clear(); + } + clear_has_answer(); +} +inline const ::std::string& ChallengeAnsweredRequest::answer() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.answer) + return *answer_; +} +inline void ChallengeAnsweredRequest::set_answer(const ::std::string& value) { + set_has_answer(); + if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + answer_ = new ::std::string; + } + answer_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.answer) +} +inline void ChallengeAnsweredRequest::set_answer(const char* value) { + set_has_answer(); + if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + answer_ = new ::std::string; + } + answer_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.answer) +} +inline void ChallengeAnsweredRequest::set_answer(const char* value, size_t size) { + set_has_answer(); + if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + answer_ = new ::std::string; + } + answer_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.answer) +} +inline ::std::string* ChallengeAnsweredRequest::mutable_answer() { + set_has_answer(); + if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + answer_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.answer) + return answer_; +} +inline ::std::string* ChallengeAnsweredRequest::release_answer() { + clear_has_answer(); + if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = answer_; + answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ChallengeAnsweredRequest::set_allocated_answer(::std::string* answer) { + if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete answer_; + } + if (answer) { + set_has_answer(); + answer_ = answer; + } else { + clear_has_answer(); + answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.answer) +} + +// optional bytes data = 2; +inline bool ChallengeAnsweredRequest::has_data() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ChallengeAnsweredRequest::set_has_data() { + _has_bits_[0] |= 0x00000002u; +} +inline void ChallengeAnsweredRequest::clear_has_data() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ChallengeAnsweredRequest::clear_data() { + if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_->clear(); + } + clear_has_data(); +} +inline const ::std::string& ChallengeAnsweredRequest::data() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.data) + return *data_; +} +inline void ChallengeAnsweredRequest::set_data(const ::std::string& value) { + set_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_ = new ::std::string; + } + data_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.data) +} +inline void ChallengeAnsweredRequest::set_data(const char* value) { + set_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_ = new ::std::string; + } + data_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.data) +} +inline void ChallengeAnsweredRequest::set_data(const void* value, size_t size) { + set_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_ = new ::std::string; + } + data_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.data) +} +inline ::std::string* ChallengeAnsweredRequest::mutable_data() { + set_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.data) + return data_; +} +inline ::std::string* ChallengeAnsweredRequest::release_data() { + clear_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = data_; + data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ChallengeAnsweredRequest::set_allocated_data(::std::string* data) { + if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete data_; + } + if (data) { + set_has_data(); + data_ = data; + } else { + clear_has_data(); + data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.data) +} + +// optional uint32 id = 3; +inline bool ChallengeAnsweredRequest::has_id() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ChallengeAnsweredRequest::set_has_id() { + _has_bits_[0] |= 0x00000004u; +} +inline void ChallengeAnsweredRequest::clear_has_id() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ChallengeAnsweredRequest::clear_id() { + id_ = 0u; + clear_has_id(); +} +inline ::google::protobuf::uint32 ChallengeAnsweredRequest::id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.id) + return id_; +} +inline void ChallengeAnsweredRequest::set_id(::google::protobuf::uint32 value) { + set_has_id(); + id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.id) +} + +// ------------------------------------------------------------------- + +// ChallengeAnsweredResponse + +// optional bytes data = 1; +inline bool ChallengeAnsweredResponse::has_data() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ChallengeAnsweredResponse::set_has_data() { + _has_bits_[0] |= 0x00000001u; +} +inline void ChallengeAnsweredResponse::clear_has_data() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ChallengeAnsweredResponse::clear_data() { + if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_->clear(); + } + clear_has_data(); +} +inline const ::std::string& ChallengeAnsweredResponse::data() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.data) + return *data_; +} +inline void ChallengeAnsweredResponse::set_data(const ::std::string& value) { + set_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_ = new ::std::string; + } + data_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.data) +} +inline void ChallengeAnsweredResponse::set_data(const char* value) { + set_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_ = new ::std::string; + } + data_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.data) +} +inline void ChallengeAnsweredResponse::set_data(const void* value, size_t size) { + set_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_ = new ::std::string; + } + data_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.data) +} +inline ::std::string* ChallengeAnsweredResponse::mutable_data() { + set_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + data_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.data) + return data_; +} +inline ::std::string* ChallengeAnsweredResponse::release_data() { + clear_has_data(); + if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = data_; + data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ChallengeAnsweredResponse::set_allocated_data(::std::string* data) { + if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete data_; + } + if (data) { + set_has_data(); + data_ = data; + } else { + clear_has_data(); + data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.data) +} + +// optional bool do_retry = 2; +inline bool ChallengeAnsweredResponse::has_do_retry() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ChallengeAnsweredResponse::set_has_do_retry() { + _has_bits_[0] |= 0x00000002u; +} +inline void ChallengeAnsweredResponse::clear_has_do_retry() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ChallengeAnsweredResponse::clear_do_retry() { + do_retry_ = false; + clear_has_do_retry(); +} +inline bool ChallengeAnsweredResponse::do_retry() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.do_retry) + return do_retry_; +} +inline void ChallengeAnsweredResponse::set_do_retry(bool value) { + set_has_do_retry(); + do_retry_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.do_retry) +} + +// optional bool record_not_found = 3; +inline bool ChallengeAnsweredResponse::has_record_not_found() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ChallengeAnsweredResponse::set_has_record_not_found() { + _has_bits_[0] |= 0x00000004u; +} +inline void ChallengeAnsweredResponse::clear_has_record_not_found() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ChallengeAnsweredResponse::clear_record_not_found() { + record_not_found_ = false; + clear_has_record_not_found(); +} +inline bool ChallengeAnsweredResponse::record_not_found() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.record_not_found) + return record_not_found_; +} +inline void ChallengeAnsweredResponse::set_record_not_found(bool value) { + set_has_record_not_found(); + record_not_found_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.record_not_found) +} + +// ------------------------------------------------------------------- + +// ChallengeCancelledRequest + +// optional uint32 id = 1; +inline bool ChallengeCancelledRequest::has_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ChallengeCancelledRequest::set_has_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void ChallengeCancelledRequest::clear_has_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ChallengeCancelledRequest::clear_id() { + id_ = 0u; + clear_has_id(); +} +inline ::google::protobuf::uint32 ChallengeCancelledRequest::id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeCancelledRequest.id) + return id_; +} +inline void ChallengeCancelledRequest::set_id(::google::protobuf::uint32 value) { + set_has_id(); + id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeCancelledRequest.id) +} + +// ------------------------------------------------------------------- + +// SendChallengeToUserRequest + +// optional .bgs.protocol.ProcessId peer_id = 1; +inline bool SendChallengeToUserRequest::has_peer_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SendChallengeToUserRequest::set_has_peer_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void SendChallengeToUserRequest::clear_has_peer_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SendChallengeToUserRequest::clear_peer_id() { + if (peer_id_ != NULL) peer_id_->::bgs::protocol::ProcessId::Clear(); + clear_has_peer_id(); +} +inline const ::bgs::protocol::ProcessId& SendChallengeToUserRequest::peer_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserRequest.peer_id) + return peer_id_ != NULL ? *peer_id_ : *default_instance_->peer_id_; +} +inline ::bgs::protocol::ProcessId* SendChallengeToUserRequest::mutable_peer_id() { + set_has_peer_id(); + if (peer_id_ == NULL) peer_id_ = new ::bgs::protocol::ProcessId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.SendChallengeToUserRequest.peer_id) + return peer_id_; +} +inline ::bgs::protocol::ProcessId* SendChallengeToUserRequest::release_peer_id() { + clear_has_peer_id(); + ::bgs::protocol::ProcessId* temp = peer_id_; + peer_id_ = NULL; + return temp; +} +inline void SendChallengeToUserRequest::set_allocated_peer_id(::bgs::protocol::ProcessId* peer_id) { + delete peer_id_; + peer_id_ = peer_id; + if (peer_id) { + set_has_peer_id(); + } else { + clear_has_peer_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.SendChallengeToUserRequest.peer_id) +} + +// optional .bgs.protocol.EntityId game_account_id = 2; +inline bool SendChallengeToUserRequest::has_game_account_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void SendChallengeToUserRequest::set_has_game_account_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void SendChallengeToUserRequest::clear_has_game_account_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void SendChallengeToUserRequest::clear_game_account_id() { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_game_account_id(); +} +inline const ::bgs::protocol::EntityId& SendChallengeToUserRequest::game_account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserRequest.game_account_id) + return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_; +} +inline ::bgs::protocol::EntityId* SendChallengeToUserRequest::mutable_game_account_id() { + set_has_game_account_id(); + if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.SendChallengeToUserRequest.game_account_id) + return game_account_id_; +} +inline ::bgs::protocol::EntityId* SendChallengeToUserRequest::release_game_account_id() { + clear_has_game_account_id(); + ::bgs::protocol::EntityId* temp = game_account_id_; + game_account_id_ = NULL; + return temp; +} +inline void SendChallengeToUserRequest::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) { + delete game_account_id_; + game_account_id_ = game_account_id; + if (game_account_id) { + set_has_game_account_id(); + } else { + clear_has_game_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.SendChallengeToUserRequest.game_account_id) +} + +// repeated .bgs.protocol.challenge.v1.Challenge challenges = 3; +inline int SendChallengeToUserRequest::challenges_size() const { + return challenges_.size(); +} +inline void SendChallengeToUserRequest::clear_challenges() { + challenges_.Clear(); +} +inline const ::bgs::protocol::challenge::v1::Challenge& SendChallengeToUserRequest::challenges(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserRequest.challenges) + return challenges_.Get(index); +} +inline ::bgs::protocol::challenge::v1::Challenge* SendChallengeToUserRequest::mutable_challenges(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.SendChallengeToUserRequest.challenges) + return challenges_.Mutable(index); +} +inline ::bgs::protocol::challenge::v1::Challenge* SendChallengeToUserRequest::add_challenges() { + // @@protoc_insertion_point(field_add:bgs.protocol.challenge.v1.SendChallengeToUserRequest.challenges) + return challenges_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge >& +SendChallengeToUserRequest::challenges() const { + // @@protoc_insertion_point(field_list:bgs.protocol.challenge.v1.SendChallengeToUserRequest.challenges) + return challenges_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge >* +SendChallengeToUserRequest::mutable_challenges() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.challenge.v1.SendChallengeToUserRequest.challenges) + return &challenges_; +} + +// required fixed32 context = 4; +inline bool SendChallengeToUserRequest::has_context() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void SendChallengeToUserRequest::set_has_context() { + _has_bits_[0] |= 0x00000008u; +} +inline void SendChallengeToUserRequest::clear_has_context() { + _has_bits_[0] &= ~0x00000008u; +} +inline void SendChallengeToUserRequest::clear_context() { + context_ = 0u; + clear_has_context(); +} +inline ::google::protobuf::uint32 SendChallengeToUserRequest::context() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserRequest.context) + return context_; +} +inline void SendChallengeToUserRequest::set_context(::google::protobuf::uint32 value) { + set_has_context(); + context_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.SendChallengeToUserRequest.context) +} + +// optional uint64 timeout = 5; +inline bool SendChallengeToUserRequest::has_timeout() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void SendChallengeToUserRequest::set_has_timeout() { + _has_bits_[0] |= 0x00000010u; +} +inline void SendChallengeToUserRequest::clear_has_timeout() { + _has_bits_[0] &= ~0x00000010u; +} +inline void SendChallengeToUserRequest::clear_timeout() { + timeout_ = GOOGLE_ULONGLONG(0); + clear_has_timeout(); +} +inline ::google::protobuf::uint64 SendChallengeToUserRequest::timeout() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserRequest.timeout) + return timeout_; +} +inline void SendChallengeToUserRequest::set_timeout(::google::protobuf::uint64 value) { + set_has_timeout(); + timeout_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.SendChallengeToUserRequest.timeout) +} + +// repeated .bgs.protocol.Attribute attributes = 6; +inline int SendChallengeToUserRequest::attributes_size() const { + return attributes_.size(); +} +inline void SendChallengeToUserRequest::clear_attributes() { + attributes_.Clear(); +} +inline const ::bgs::protocol::Attribute& SendChallengeToUserRequest::attributes(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserRequest.attributes) + return attributes_.Get(index); +} +inline ::bgs::protocol::Attribute* SendChallengeToUserRequest::mutable_attributes(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.SendChallengeToUserRequest.attributes) + return attributes_.Mutable(index); +} +inline ::bgs::protocol::Attribute* SendChallengeToUserRequest::add_attributes() { + // @@protoc_insertion_point(field_add:bgs.protocol.challenge.v1.SendChallengeToUserRequest.attributes) + return attributes_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& +SendChallengeToUserRequest::attributes() const { + // @@protoc_insertion_point(field_list:bgs.protocol.challenge.v1.SendChallengeToUserRequest.attributes) + return attributes_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* +SendChallengeToUserRequest::mutable_attributes() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.challenge.v1.SendChallengeToUserRequest.attributes) + return &attributes_; +} + +// optional .bgs.protocol.ProcessId host = 7; +inline bool SendChallengeToUserRequest::has_host() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void SendChallengeToUserRequest::set_has_host() { + _has_bits_[0] |= 0x00000040u; +} +inline void SendChallengeToUserRequest::clear_has_host() { + _has_bits_[0] &= ~0x00000040u; +} +inline void SendChallengeToUserRequest::clear_host() { + if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear(); + clear_has_host(); +} +inline const ::bgs::protocol::ProcessId& SendChallengeToUserRequest::host() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserRequest.host) + return host_ != NULL ? *host_ : *default_instance_->host_; +} +inline ::bgs::protocol::ProcessId* SendChallengeToUserRequest::mutable_host() { + set_has_host(); + if (host_ == NULL) host_ = new ::bgs::protocol::ProcessId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.SendChallengeToUserRequest.host) + return host_; +} +inline ::bgs::protocol::ProcessId* SendChallengeToUserRequest::release_host() { + clear_has_host(); + ::bgs::protocol::ProcessId* temp = host_; + host_ = NULL; + return temp; +} +inline void SendChallengeToUserRequest::set_allocated_host(::bgs::protocol::ProcessId* host) { + delete host_; + host_ = host; + if (host) { + set_has_host(); + } else { + clear_has_host(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.SendChallengeToUserRequest.host) +} + +// optional .bgs.protocol.EntityId account_id = 8; +inline bool SendChallengeToUserRequest::has_account_id() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void SendChallengeToUserRequest::set_has_account_id() { + _has_bits_[0] |= 0x00000080u; +} +inline void SendChallengeToUserRequest::clear_has_account_id() { + _has_bits_[0] &= ~0x00000080u; +} +inline void SendChallengeToUserRequest::clear_account_id() { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_account_id(); +} +inline const ::bgs::protocol::EntityId& SendChallengeToUserRequest::account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserRequest.account_id) + return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_; +} +inline ::bgs::protocol::EntityId* SendChallengeToUserRequest::mutable_account_id() { + set_has_account_id(); + if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.SendChallengeToUserRequest.account_id) + return account_id_; +} +inline ::bgs::protocol::EntityId* SendChallengeToUserRequest::release_account_id() { + clear_has_account_id(); + ::bgs::protocol::EntityId* temp = account_id_; + account_id_ = NULL; + return temp; +} +inline void SendChallengeToUserRequest::set_allocated_account_id(::bgs::protocol::EntityId* account_id) { + delete account_id_; + account_id_ = account_id; + if (account_id) { + set_has_account_id(); + } else { + clear_has_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.SendChallengeToUserRequest.account_id) +} + +// ------------------------------------------------------------------- + +// SendChallengeToUserResponse + +// optional uint32 id = 1; +inline bool SendChallengeToUserResponse::has_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SendChallengeToUserResponse::set_has_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void SendChallengeToUserResponse::clear_has_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SendChallengeToUserResponse::clear_id() { + id_ = 0u; + clear_has_id(); +} +inline ::google::protobuf::uint32 SendChallengeToUserResponse::id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserResponse.id) + return id_; +} +inline void SendChallengeToUserResponse::set_id(::google::protobuf::uint32 value) { + set_has_id(); + id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.SendChallengeToUserResponse.id) +} + +// ------------------------------------------------------------------- + +// ChallengeUserRequest + +// repeated .bgs.protocol.challenge.v1.Challenge challenges = 1; +inline int ChallengeUserRequest::challenges_size() const { + return challenges_.size(); +} +inline void ChallengeUserRequest::clear_challenges() { + challenges_.Clear(); +} +inline const ::bgs::protocol::challenge::v1::Challenge& ChallengeUserRequest::challenges(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeUserRequest.challenges) + return challenges_.Get(index); +} +inline ::bgs::protocol::challenge::v1::Challenge* ChallengeUserRequest::mutable_challenges(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeUserRequest.challenges) + return challenges_.Mutable(index); +} +inline ::bgs::protocol::challenge::v1::Challenge* ChallengeUserRequest::add_challenges() { + // @@protoc_insertion_point(field_add:bgs.protocol.challenge.v1.ChallengeUserRequest.challenges) + return challenges_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge >& +ChallengeUserRequest::challenges() const { + // @@protoc_insertion_point(field_list:bgs.protocol.challenge.v1.ChallengeUserRequest.challenges) + return challenges_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge >* +ChallengeUserRequest::mutable_challenges() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.challenge.v1.ChallengeUserRequest.challenges) + return &challenges_; +} + +// required fixed32 context = 2; +inline bool ChallengeUserRequest::has_context() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ChallengeUserRequest::set_has_context() { + _has_bits_[0] |= 0x00000002u; +} +inline void ChallengeUserRequest::clear_has_context() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ChallengeUserRequest::clear_context() { + context_ = 0u; + clear_has_context(); +} +inline ::google::protobuf::uint32 ChallengeUserRequest::context() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeUserRequest.context) + return context_; +} +inline void ChallengeUserRequest::set_context(::google::protobuf::uint32 value) { + set_has_context(); + context_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeUserRequest.context) +} + +// optional uint32 id = 3; +inline bool ChallengeUserRequest::has_id() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ChallengeUserRequest::set_has_id() { + _has_bits_[0] |= 0x00000004u; +} +inline void ChallengeUserRequest::clear_has_id() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ChallengeUserRequest::clear_id() { + id_ = 0u; + clear_has_id(); +} +inline ::google::protobuf::uint32 ChallengeUserRequest::id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeUserRequest.id) + return id_; +} +inline void ChallengeUserRequest::set_id(::google::protobuf::uint32 value) { + set_has_id(); + id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeUserRequest.id) +} + +// optional uint64 deadline = 4; +inline bool ChallengeUserRequest::has_deadline() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void ChallengeUserRequest::set_has_deadline() { + _has_bits_[0] |= 0x00000008u; +} +inline void ChallengeUserRequest::clear_has_deadline() { + _has_bits_[0] &= ~0x00000008u; +} +inline void ChallengeUserRequest::clear_deadline() { + deadline_ = GOOGLE_ULONGLONG(0); + clear_has_deadline(); +} +inline ::google::protobuf::uint64 ChallengeUserRequest::deadline() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeUserRequest.deadline) + return deadline_; +} +inline void ChallengeUserRequest::set_deadline(::google::protobuf::uint64 value) { + set_has_deadline(); + deadline_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeUserRequest.deadline) +} + +// repeated .bgs.protocol.Attribute attributes = 5; +inline int ChallengeUserRequest::attributes_size() const { + return attributes_.size(); +} +inline void ChallengeUserRequest::clear_attributes() { + attributes_.Clear(); +} +inline const ::bgs::protocol::Attribute& ChallengeUserRequest::attributes(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeUserRequest.attributes) + return attributes_.Get(index); +} +inline ::bgs::protocol::Attribute* ChallengeUserRequest::mutable_attributes(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeUserRequest.attributes) + return attributes_.Mutable(index); +} +inline ::bgs::protocol::Attribute* ChallengeUserRequest::add_attributes() { + // @@protoc_insertion_point(field_add:bgs.protocol.challenge.v1.ChallengeUserRequest.attributes) + return attributes_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& +ChallengeUserRequest::attributes() const { + // @@protoc_insertion_point(field_list:bgs.protocol.challenge.v1.ChallengeUserRequest.attributes) + return attributes_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* +ChallengeUserRequest::mutable_attributes() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.challenge.v1.ChallengeUserRequest.attributes) + return &attributes_; +} + +// optional .bgs.protocol.EntityId game_account_id = 6; +inline bool ChallengeUserRequest::has_game_account_id() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void ChallengeUserRequest::set_has_game_account_id() { + _has_bits_[0] |= 0x00000020u; +} +inline void ChallengeUserRequest::clear_has_game_account_id() { + _has_bits_[0] &= ~0x00000020u; +} +inline void ChallengeUserRequest::clear_game_account_id() { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_game_account_id(); +} +inline const ::bgs::protocol::EntityId& ChallengeUserRequest::game_account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeUserRequest.game_account_id) + return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_; +} +inline ::bgs::protocol::EntityId* ChallengeUserRequest::mutable_game_account_id() { + set_has_game_account_id(); + if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeUserRequest.game_account_id) + return game_account_id_; +} +inline ::bgs::protocol::EntityId* ChallengeUserRequest::release_game_account_id() { + clear_has_game_account_id(); + ::bgs::protocol::EntityId* temp = game_account_id_; + game_account_id_ = NULL; + return temp; +} +inline void ChallengeUserRequest::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) { + delete game_account_id_; + game_account_id_ = game_account_id; + if (game_account_id) { + set_has_game_account_id(); + } else { + clear_has_game_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.ChallengeUserRequest.game_account_id) +} + +// ------------------------------------------------------------------- + +// ChallengeResultRequest + +// optional uint32 id = 1; +inline bool ChallengeResultRequest::has_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ChallengeResultRequest::set_has_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void ChallengeResultRequest::clear_has_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ChallengeResultRequest::clear_id() { + id_ = 0u; + clear_has_id(); +} +inline ::google::protobuf::uint32 ChallengeResultRequest::id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeResultRequest.id) + return id_; +} +inline void ChallengeResultRequest::set_id(::google::protobuf::uint32 value) { + set_has_id(); + id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeResultRequest.id) +} + +// optional fixed32 type = 2; +inline bool ChallengeResultRequest::has_type() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ChallengeResultRequest::set_has_type() { + _has_bits_[0] |= 0x00000002u; +} +inline void ChallengeResultRequest::clear_has_type() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ChallengeResultRequest::clear_type() { + type_ = 0u; + clear_has_type(); +} +inline ::google::protobuf::uint32 ChallengeResultRequest::type() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeResultRequest.type) + return type_; +} +inline void ChallengeResultRequest::set_type(::google::protobuf::uint32 value) { + set_has_type(); + type_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeResultRequest.type) +} + +// optional uint32 error_id = 3; +inline bool ChallengeResultRequest::has_error_id() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ChallengeResultRequest::set_has_error_id() { + _has_bits_[0] |= 0x00000004u; +} +inline void ChallengeResultRequest::clear_has_error_id() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ChallengeResultRequest::clear_error_id() { + error_id_ = 0u; + clear_has_error_id(); +} +inline ::google::protobuf::uint32 ChallengeResultRequest::error_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeResultRequest.error_id) + return error_id_; +} +inline void ChallengeResultRequest::set_error_id(::google::protobuf::uint32 value) { + set_has_error_id(); + error_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeResultRequest.error_id) +} + +// optional bytes answer = 4; +inline bool ChallengeResultRequest::has_answer() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void ChallengeResultRequest::set_has_answer() { + _has_bits_[0] |= 0x00000008u; +} +inline void ChallengeResultRequest::clear_has_answer() { + _has_bits_[0] &= ~0x00000008u; +} +inline void ChallengeResultRequest::clear_answer() { + if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + answer_->clear(); + } + clear_has_answer(); +} +inline const ::std::string& ChallengeResultRequest::answer() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeResultRequest.answer) + return *answer_; +} +inline void ChallengeResultRequest::set_answer(const ::std::string& value) { + set_has_answer(); + if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + answer_ = new ::std::string; + } + answer_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeResultRequest.answer) +} +inline void ChallengeResultRequest::set_answer(const char* value) { + set_has_answer(); + if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + answer_ = new ::std::string; + } + answer_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.ChallengeResultRequest.answer) +} +inline void ChallengeResultRequest::set_answer(const void* value, size_t size) { + set_has_answer(); + if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + answer_ = new ::std::string; + } + answer_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.ChallengeResultRequest.answer) +} +inline ::std::string* ChallengeResultRequest::mutable_answer() { + set_has_answer(); + if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + answer_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeResultRequest.answer) + return answer_; +} +inline ::std::string* ChallengeResultRequest::release_answer() { + clear_has_answer(); + if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = answer_; + answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ChallengeResultRequest::set_allocated_answer(::std::string* answer) { + if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete answer_; + } + if (answer) { + set_has_answer(); + answer_ = answer; + } else { + clear_has_answer(); + answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.ChallengeResultRequest.answer) +} + +// ------------------------------------------------------------------- + +// ChallengeExternalRequest + +// optional string request_token = 1; +inline bool ChallengeExternalRequest::has_request_token() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ChallengeExternalRequest::set_has_request_token() { + _has_bits_[0] |= 0x00000001u; +} +inline void ChallengeExternalRequest::clear_has_request_token() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ChallengeExternalRequest::clear_request_token() { + if (request_token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + request_token_->clear(); + } + clear_has_request_token(); +} +inline const ::std::string& ChallengeExternalRequest::request_token() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeExternalRequest.request_token) + return *request_token_; +} +inline void ChallengeExternalRequest::set_request_token(const ::std::string& value) { + set_has_request_token(); + if (request_token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + request_token_ = new ::std::string; + } + request_token_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeExternalRequest.request_token) +} +inline void ChallengeExternalRequest::set_request_token(const char* value) { + set_has_request_token(); + if (request_token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + request_token_ = new ::std::string; + } + request_token_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.ChallengeExternalRequest.request_token) +} +inline void ChallengeExternalRequest::set_request_token(const char* value, size_t size) { + set_has_request_token(); + if (request_token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + request_token_ = new ::std::string; + } + request_token_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.ChallengeExternalRequest.request_token) +} +inline ::std::string* ChallengeExternalRequest::mutable_request_token() { + set_has_request_token(); + if (request_token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + request_token_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeExternalRequest.request_token) + return request_token_; +} +inline ::std::string* ChallengeExternalRequest::release_request_token() { + clear_has_request_token(); + if (request_token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = request_token_; + request_token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ChallengeExternalRequest::set_allocated_request_token(::std::string* request_token) { + if (request_token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete request_token_; + } + if (request_token) { + set_has_request_token(); + request_token_ = request_token; + } else { + clear_has_request_token(); + request_token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.ChallengeExternalRequest.request_token) +} + +// optional string payload_type = 2; +inline bool ChallengeExternalRequest::has_payload_type() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ChallengeExternalRequest::set_has_payload_type() { + _has_bits_[0] |= 0x00000002u; +} +inline void ChallengeExternalRequest::clear_has_payload_type() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ChallengeExternalRequest::clear_payload_type() { + if (payload_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + payload_type_->clear(); + } + clear_has_payload_type(); +} +inline const ::std::string& ChallengeExternalRequest::payload_type() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeExternalRequest.payload_type) + return *payload_type_; +} +inline void ChallengeExternalRequest::set_payload_type(const ::std::string& value) { + set_has_payload_type(); + if (payload_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + payload_type_ = new ::std::string; + } + payload_type_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeExternalRequest.payload_type) +} +inline void ChallengeExternalRequest::set_payload_type(const char* value) { + set_has_payload_type(); + if (payload_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + payload_type_ = new ::std::string; + } + payload_type_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.ChallengeExternalRequest.payload_type) +} +inline void ChallengeExternalRequest::set_payload_type(const char* value, size_t size) { + set_has_payload_type(); + if (payload_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + payload_type_ = new ::std::string; + } + payload_type_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.ChallengeExternalRequest.payload_type) +} +inline ::std::string* ChallengeExternalRequest::mutable_payload_type() { + set_has_payload_type(); + if (payload_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + payload_type_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeExternalRequest.payload_type) + return payload_type_; +} +inline ::std::string* ChallengeExternalRequest::release_payload_type() { + clear_has_payload_type(); + if (payload_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = payload_type_; + payload_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ChallengeExternalRequest::set_allocated_payload_type(::std::string* payload_type) { + if (payload_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete payload_type_; + } + if (payload_type) { + set_has_payload_type(); + payload_type_ = payload_type; + } else { + clear_has_payload_type(); + payload_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.ChallengeExternalRequest.payload_type) +} + +// optional bytes payload = 3; +inline bool ChallengeExternalRequest::has_payload() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ChallengeExternalRequest::set_has_payload() { + _has_bits_[0] |= 0x00000004u; +} +inline void ChallengeExternalRequest::clear_has_payload() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ChallengeExternalRequest::clear_payload() { + if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + payload_->clear(); + } + clear_has_payload(); +} +inline const ::std::string& ChallengeExternalRequest::payload() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeExternalRequest.payload) + return *payload_; +} +inline void ChallengeExternalRequest::set_payload(const ::std::string& value) { + set_has_payload(); + if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + payload_ = new ::std::string; + } + payload_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeExternalRequest.payload) +} +inline void ChallengeExternalRequest::set_payload(const char* value) { + set_has_payload(); + if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + payload_ = new ::std::string; + } + payload_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.ChallengeExternalRequest.payload) +} +inline void ChallengeExternalRequest::set_payload(const void* value, size_t size) { + set_has_payload(); + if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + payload_ = new ::std::string; + } + payload_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.ChallengeExternalRequest.payload) +} +inline ::std::string* ChallengeExternalRequest::mutable_payload() { + set_has_payload(); + if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + payload_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeExternalRequest.payload) + return payload_; +} +inline ::std::string* ChallengeExternalRequest::release_payload() { + clear_has_payload(); + if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = payload_; + payload_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ChallengeExternalRequest::set_allocated_payload(::std::string* payload) { + if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete payload_; + } + if (payload) { + set_has_payload(); + payload_ = payload; + } else { + clear_has_payload(); + payload_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.ChallengeExternalRequest.payload) +} + +// ------------------------------------------------------------------- + +// ChallengeExternalResult + +// optional string request_token = 1; +inline bool ChallengeExternalResult::has_request_token() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ChallengeExternalResult::set_has_request_token() { + _has_bits_[0] |= 0x00000001u; +} +inline void ChallengeExternalResult::clear_has_request_token() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ChallengeExternalResult::clear_request_token() { + if (request_token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + request_token_->clear(); + } + clear_has_request_token(); +} +inline const ::std::string& ChallengeExternalResult::request_token() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeExternalResult.request_token) + return *request_token_; +} +inline void ChallengeExternalResult::set_request_token(const ::std::string& value) { + set_has_request_token(); + if (request_token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + request_token_ = new ::std::string; + } + request_token_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeExternalResult.request_token) +} +inline void ChallengeExternalResult::set_request_token(const char* value) { + set_has_request_token(); + if (request_token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + request_token_ = new ::std::string; + } + request_token_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.ChallengeExternalResult.request_token) +} +inline void ChallengeExternalResult::set_request_token(const char* value, size_t size) { + set_has_request_token(); + if (request_token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + request_token_ = new ::std::string; + } + request_token_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.ChallengeExternalResult.request_token) +} +inline ::std::string* ChallengeExternalResult::mutable_request_token() { + set_has_request_token(); + if (request_token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + request_token_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeExternalResult.request_token) + return request_token_; +} +inline ::std::string* ChallengeExternalResult::release_request_token() { + clear_has_request_token(); + if (request_token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = request_token_; + request_token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ChallengeExternalResult::set_allocated_request_token(::std::string* request_token) { + if (request_token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete request_token_; + } + if (request_token) { + set_has_request_token(); + request_token_ = request_token; + } else { + clear_has_request_token(); + request_token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.ChallengeExternalResult.request_token) +} + +// optional bool passed = 2 [default = true]; +inline bool ChallengeExternalResult::has_passed() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ChallengeExternalResult::set_has_passed() { + _has_bits_[0] |= 0x00000002u; +} +inline void ChallengeExternalResult::clear_has_passed() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ChallengeExternalResult::clear_passed() { + passed_ = true; + clear_has_passed(); +} +inline bool ChallengeExternalResult::passed() const { + // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeExternalResult.passed) + return passed_; +} +inline void ChallengeExternalResult::set_passed(bool value) { + set_has_passed(); + passed_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeExternalResult.passed) +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace challenge +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_challenge_5fservice_2eproto__INCLUDED diff --git a/src/server/proto/Client/channel_service.pb.cc b/src/server/proto/Client/channel_service.pb.cc new file mode 100644 index 00000000000..3c2b099d938 --- /dev/null +++ b/src/server/proto/Client/channel_service.pb.cc @@ -0,0 +1,6487 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: channel_service.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "channel_service.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +#include "BattlenetRpcErrorCodes.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { +namespace channel { +namespace v1 { + +namespace { + +const ::google::protobuf::Descriptor* AddMemberRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AddMemberRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* RemoveMemberRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + RemoveMemberRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* UnsubscribeMemberRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + UnsubscribeMemberRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* SendMessageRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SendMessageRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* UpdateChannelStateRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + UpdateChannelStateRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* UpdateMemberStateRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + UpdateMemberStateRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* DissolveRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + DissolveRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* SetRolesRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SetRolesRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* JoinNotification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + JoinNotification_reflection_ = NULL; +const ::google::protobuf::Descriptor* MemberAddedNotification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + MemberAddedNotification_reflection_ = NULL; +const ::google::protobuf::Descriptor* LeaveNotification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + LeaveNotification_reflection_ = NULL; +const ::google::protobuf::Descriptor* MemberRemovedNotification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + MemberRemovedNotification_reflection_ = NULL; +const ::google::protobuf::Descriptor* SendMessageNotification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SendMessageNotification_reflection_ = NULL; +const ::google::protobuf::Descriptor* UpdateChannelStateNotification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + UpdateChannelStateNotification_reflection_ = NULL; +const ::google::protobuf::Descriptor* UpdateMemberStateNotification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + UpdateMemberStateNotification_reflection_ = NULL; +const ::google::protobuf::ServiceDescriptor* ChannelService_descriptor_ = NULL; +const ::google::protobuf::ServiceDescriptor* ChannelListener_descriptor_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_channel_5fservice_2eproto() { + protobuf_AddDesc_channel_5fservice_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "channel_service.proto"); + GOOGLE_CHECK(file != NULL); + AddMemberRequest_descriptor_ = file->message_type(0); + static const int AddMemberRequest_offsets_[5] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddMemberRequest, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddMemberRequest, member_identity_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddMemberRequest, member_state_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddMemberRequest, object_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddMemberRequest, subscribe_), + }; + AddMemberRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AddMemberRequest_descriptor_, + AddMemberRequest::default_instance_, + AddMemberRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddMemberRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddMemberRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AddMemberRequest)); + RemoveMemberRequest_descriptor_ = file->message_type(1); + static const int RemoveMemberRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveMemberRequest, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveMemberRequest, member_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveMemberRequest, reason_), + }; + RemoveMemberRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + RemoveMemberRequest_descriptor_, + RemoveMemberRequest::default_instance_, + RemoveMemberRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveMemberRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveMemberRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(RemoveMemberRequest)); + UnsubscribeMemberRequest_descriptor_ = file->message_type(2); + static const int UnsubscribeMemberRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeMemberRequest, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeMemberRequest, member_id_), + }; + UnsubscribeMemberRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + UnsubscribeMemberRequest_descriptor_, + UnsubscribeMemberRequest::default_instance_, + UnsubscribeMemberRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeMemberRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeMemberRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(UnsubscribeMemberRequest)); + SendMessageRequest_descriptor_ = file->message_type(3); + static const int SendMessageRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageRequest, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageRequest, message_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageRequest, required_privileges_), + }; + SendMessageRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + SendMessageRequest_descriptor_, + SendMessageRequest::default_instance_, + SendMessageRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(SendMessageRequest)); + UpdateChannelStateRequest_descriptor_ = file->message_type(4); + static const int UpdateChannelStateRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateRequest, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateRequest, state_change_), + }; + UpdateChannelStateRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + UpdateChannelStateRequest_descriptor_, + UpdateChannelStateRequest::default_instance_, + UpdateChannelStateRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(UpdateChannelStateRequest)); + UpdateMemberStateRequest_descriptor_ = file->message_type(5); + static const int UpdateMemberStateRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateRequest, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateRequest, state_change_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateRequest, removed_role_), + }; + UpdateMemberStateRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + UpdateMemberStateRequest_descriptor_, + UpdateMemberStateRequest::default_instance_, + UpdateMemberStateRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(UpdateMemberStateRequest)); + DissolveRequest_descriptor_ = file->message_type(6); + static const int DissolveRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DissolveRequest, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DissolveRequest, reason_), + }; + DissolveRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + DissolveRequest_descriptor_, + DissolveRequest::default_instance_, + DissolveRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DissolveRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DissolveRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(DissolveRequest)); + SetRolesRequest_descriptor_ = file->message_type(7); + static const int SetRolesRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetRolesRequest, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetRolesRequest, role_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetRolesRequest, member_id_), + }; + SetRolesRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + SetRolesRequest_descriptor_, + SetRolesRequest::default_instance_, + SetRolesRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetRolesRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetRolesRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(SetRolesRequest)); + JoinNotification_descriptor_ = file->message_type(8); + static const int JoinNotification_offsets_[5] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinNotification, self_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinNotification, member_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinNotification, channel_state_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinNotification, channel_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinNotification, subscriber_), + }; + JoinNotification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + JoinNotification_descriptor_, + JoinNotification::default_instance_, + JoinNotification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinNotification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinNotification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(JoinNotification)); + MemberAddedNotification_descriptor_ = file->message_type(9); + static const int MemberAddedNotification_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAddedNotification, member_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAddedNotification, channel_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAddedNotification, subscriber_), + }; + MemberAddedNotification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + MemberAddedNotification_descriptor_, + MemberAddedNotification::default_instance_, + MemberAddedNotification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAddedNotification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAddedNotification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(MemberAddedNotification)); + LeaveNotification_descriptor_ = file->message_type(10); + static const int LeaveNotification_offsets_[5] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveNotification, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveNotification, member_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveNotification, reason_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveNotification, channel_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveNotification, subscriber_), + }; + LeaveNotification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + LeaveNotification_descriptor_, + LeaveNotification::default_instance_, + LeaveNotification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveNotification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveNotification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(LeaveNotification)); + MemberRemovedNotification_descriptor_ = file->message_type(11); + static const int MemberRemovedNotification_offsets_[5] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, member_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, reason_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, channel_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, subscriber_), + }; + MemberRemovedNotification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + MemberRemovedNotification_descriptor_, + MemberRemovedNotification::default_instance_, + MemberRemovedNotification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(MemberRemovedNotification)); + SendMessageNotification_descriptor_ = file->message_type(12); + static const int SendMessageNotification_offsets_[6] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageNotification, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageNotification, message_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageNotification, required_privileges_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageNotification, identity_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageNotification, channel_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageNotification, subscriber_), + }; + SendMessageNotification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + SendMessageNotification_descriptor_, + SendMessageNotification::default_instance_, + SendMessageNotification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageNotification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageNotification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(SendMessageNotification)); + UpdateChannelStateNotification_descriptor_ = file->message_type(13); + static const int UpdateChannelStateNotification_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateNotification, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateNotification, state_change_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateNotification, channel_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateNotification, subscriber_), + }; + UpdateChannelStateNotification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + UpdateChannelStateNotification_descriptor_, + UpdateChannelStateNotification::default_instance_, + UpdateChannelStateNotification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateNotification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateNotification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(UpdateChannelStateNotification)); + UpdateMemberStateNotification_descriptor_ = file->message_type(14); + static const int UpdateMemberStateNotification_offsets_[5] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateNotification, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateNotification, state_change_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateNotification, removed_role_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateNotification, channel_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateNotification, subscriber_), + }; + UpdateMemberStateNotification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + UpdateMemberStateNotification_descriptor_, + UpdateMemberStateNotification::default_instance_, + UpdateMemberStateNotification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateNotification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateNotification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(UpdateMemberStateNotification)); + ChannelService_descriptor_ = file->service(0); + ChannelListener_descriptor_ = file->service(1); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_channel_5fservice_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AddMemberRequest_descriptor_, &AddMemberRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + RemoveMemberRequest_descriptor_, &RemoveMemberRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + UnsubscribeMemberRequest_descriptor_, &UnsubscribeMemberRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SendMessageRequest_descriptor_, &SendMessageRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + UpdateChannelStateRequest_descriptor_, &UpdateChannelStateRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + UpdateMemberStateRequest_descriptor_, &UpdateMemberStateRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + DissolveRequest_descriptor_, &DissolveRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SetRolesRequest_descriptor_, &SetRolesRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + JoinNotification_descriptor_, &JoinNotification::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + MemberAddedNotification_descriptor_, &MemberAddedNotification::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + LeaveNotification_descriptor_, &LeaveNotification::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + MemberRemovedNotification_descriptor_, &MemberRemovedNotification::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SendMessageNotification_descriptor_, &SendMessageNotification::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + UpdateChannelStateNotification_descriptor_, &UpdateChannelStateNotification::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + UpdateMemberStateNotification_descriptor_, &UpdateMemberStateNotification::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_channel_5fservice_2eproto() { + delete AddMemberRequest::default_instance_; + delete AddMemberRequest_reflection_; + delete RemoveMemberRequest::default_instance_; + delete RemoveMemberRequest_reflection_; + delete UnsubscribeMemberRequest::default_instance_; + delete UnsubscribeMemberRequest_reflection_; + delete SendMessageRequest::default_instance_; + delete SendMessageRequest_reflection_; + delete UpdateChannelStateRequest::default_instance_; + delete UpdateChannelStateRequest_reflection_; + delete UpdateMemberStateRequest::default_instance_; + delete UpdateMemberStateRequest_reflection_; + delete DissolveRequest::default_instance_; + delete DissolveRequest_reflection_; + delete SetRolesRequest::default_instance_; + delete SetRolesRequest_reflection_; + delete JoinNotification::default_instance_; + delete JoinNotification_reflection_; + delete MemberAddedNotification::default_instance_; + delete MemberAddedNotification_reflection_; + delete LeaveNotification::default_instance_; + delete LeaveNotification_reflection_; + delete MemberRemovedNotification::default_instance_; + delete MemberRemovedNotification_reflection_; + delete SendMessageNotification::default_instance_; + delete SendMessageNotification_reflection_; + delete UpdateChannelStateNotification::default_instance_; + delete UpdateChannelStateNotification_reflection_; + delete UpdateMemberStateNotification::default_instance_; + delete UpdateMemberStateNotification_reflection_; +} + +void protobuf_AddDesc_channel_5fservice_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::bgs::protocol::account::v1::protobuf_AddDesc_account_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto(); + ::bgs::protocol::channel::v1::protobuf_AddDesc_channel_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\025channel_service.proto\022\027bgs.protocol.ch" + "annel.v1\032\023account_types.proto\032\022entity_ty" + "pes.proto\032\023channel_types.proto\032\017rpc_type" + "s.proto\"\325\001\n\020AddMemberRequest\022(\n\010agent_id" + "\030\001 \001(\0132\026.bgs.protocol.EntityId\022/\n\017member" + "_identity\030\002 \002(\0132\026.bgs.protocol.Identity\022" + ":\n\014member_state\030\003 \002(\0132$.bgs.protocol.cha" + "nnel.v1.MemberState\022\021\n\tobject_id\030\004 \002(\004\022\027" + "\n\tsubscribe\030\005 \001(\010:\004true\"z\n\023RemoveMemberR" + "equest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.protocol." + "EntityId\022)\n\tmember_id\030\002 \002(\0132\026.bgs.protoc" + "ol.EntityId\022\016\n\006reason\030\003 \001(\r\"o\n\030Unsubscri" + "beMemberRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs." + "protocol.EntityId\022)\n\tmember_id\030\002 \002(\0132\026.b" + "gs.protocol.EntityId\"\221\001\n\022SendMessageRequ" + "est\022(\n\010agent_id\030\001 \001(\0132\026.bgs.protocol.Ent" + "ityId\0221\n\007message\030\002 \002(\0132 .bgs.protocol.ch" + "annel.v1.Message\022\036\n\023required_privileges\030" + "\003 \001(\004:\0010\"\202\001\n\031UpdateChannelStateRequest\022(" + "\n\010agent_id\030\001 \001(\0132\026.bgs.protocol.EntityId" + "\022;\n\014state_change\030\002 \002(\0132%.bgs.protocol.ch" + "annel.v1.ChannelState\"\225\001\n\030UpdateMemberSt" + "ateRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.proto" + "col.EntityId\0225\n\014state_change\030\002 \003(\0132\037.bgs" + ".protocol.channel.v1.Member\022\030\n\014removed_r" + "ole\030\003 \003(\rB\002\020\001\"K\n\017DissolveRequest\022(\n\010agen" + "t_id\030\001 \001(\0132\026.bgs.protocol.EntityId\022\016\n\006re" + "ason\030\002 \001(\r\"x\n\017SetRolesRequest\022(\n\010agent_i" + "d\030\001 \001(\0132\026.bgs.protocol.EntityId\022\020\n\004role\030" + "\002 \003(\rB\002\020\001\022)\n\tmember_id\030\003 \003(\0132\026.bgs.proto" + "col.EntityId\"\237\002\n\020JoinNotification\022-\n\004sel" + "f\030\001 \001(\0132\037.bgs.protocol.channel.v1.Member" + "\022/\n\006member\030\002 \003(\0132\037.bgs.protocol.channel." + "v1.Member\022<\n\rchannel_state\030\003 \002(\0132%.bgs.p" + "rotocol.channel.v1.ChannelState\0226\n\nchann" + "el_id\030\004 \001(\0132\".bgs.protocol.channel.v1.Ch" + "annelId\0225\n\nsubscriber\030\005 \001(\0132!.bgs.protoc" + "ol.account.v1.Identity\"\271\001\n\027MemberAddedNo" + "tification\022/\n\006member\030\001 \002(\0132\037.bgs.protoco" + "l.channel.v1.Member\0226\n\nchannel_id\030\002 \001(\0132" + "\".bgs.protocol.channel.v1.ChannelId\0225\n\ns" + "ubscriber\030\003 \001(\0132!.bgs.protocol.account.v" + "1.Identity\"\347\001\n\021LeaveNotification\022(\n\010agen" + "t_id\030\001 \001(\0132\026.bgs.protocol.EntityId\022)\n\tme" + "mber_id\030\002 \002(\0132\026.bgs.protocol.EntityId\022\016\n" + "\006reason\030\003 \001(\r\0226\n\nchannel_id\030\004 \001(\0132\".bgs." + "protocol.channel.v1.ChannelId\0225\n\nsubscri" + "ber\030\005 \001(\0132!.bgs.protocol.account.v1.Iden" + "tity\"\357\001\n\031MemberRemovedNotification\022(\n\010ag" + "ent_id\030\001 \001(\0132\026.bgs.protocol.EntityId\022)\n\t" + "member_id\030\002 \002(\0132\026.bgs.protocol.EntityId\022" + "\016\n\006reason\030\003 \001(\r\0226\n\nchannel_id\030\004 \001(\0132\".bg" + "s.protocol.channel.v1.ChannelId\0225\n\nsubsc" + "riber\030\005 \001(\0132!.bgs.protocol.account.v1.Id" + "entity\"\227\002\n\027SendMessageNotification\022(\n\010ag" + "ent_id\030\001 \001(\0132\026.bgs.protocol.EntityId\0221\n\007" + "message\030\002 \002(\0132 .bgs.protocol.channel.v1." + "Message\022\036\n\023required_privileges\030\003 \001(\004:\0010\022" + "\020\n\010identity\030\004 \001(\t\0226\n\nchannel_id\030\005 \001(\0132\"." + "bgs.protocol.channel.v1.ChannelId\0225\n\nsub" + "scriber\030\006 \001(\0132!.bgs.protocol.account.v1." + "Identity\"\366\001\n\036UpdateChannelStateNotificat" + "ion\022(\n\010agent_id\030\001 \001(\0132\026.bgs.protocol.Ent" + "ityId\022;\n\014state_change\030\002 \002(\0132%.bgs.protoc" + "ol.channel.v1.ChannelState\0226\n\nchannel_id" + "\030\003 \001(\0132\".bgs.protocol.channel.v1.Channel" + "Id\0225\n\nsubscriber\030\004 \001(\0132!.bgs.protocol.ac" + "count.v1.Identity\"\211\002\n\035UpdateMemberStateN" + "otification\022(\n\010agent_id\030\001 \001(\0132\026.bgs.prot" + "ocol.EntityId\0225\n\014state_change\030\002 \003(\0132\037.bg" + "s.protocol.channel.v1.Member\022\030\n\014removed_" + "role\030\003 \003(\rB\002\020\001\0226\n\nchannel_id\030\004 \001(\0132\".bgs" + ".protocol.channel.v1.ChannelId\0225\n\nsubscr" + "iber\030\005 \001(\0132!.bgs.protocol.account.v1.Ide" + "ntity2\212\006\n\016ChannelService\022R\n\tAddMember\022)." + "bgs.protocol.channel.v1.AddMemberRequest" + "\032\024.bgs.protocol.NoData\"\004\200\265\030\001\022X\n\014RemoveMe" + "mber\022,.bgs.protocol.channel.v1.RemoveMem" + "berRequest\032\024.bgs.protocol.NoData\"\004\200\265\030\002\022V" + "\n\013SendMessage\022+.bgs.protocol.channel.v1." + "SendMessageRequest\032\024.bgs.protocol.NoData" + "\"\004\200\265\030\003\022d\n\022UpdateChannelState\0222.bgs.proto" + "col.channel.v1.UpdateChannelStateRequest" + "\032\024.bgs.protocol.NoData\"\004\200\265\030\004\022b\n\021UpdateMe" + "mberState\0221.bgs.protocol.channel.v1.Upda" + "teMemberStateRequest\032\024.bgs.protocol.NoDa" + "ta\"\004\200\265\030\005\022P\n\010Dissolve\022(.bgs.protocol.chan" + "nel.v1.DissolveRequest\032\024.bgs.protocol.No" + "Data\"\004\200\265\030\006\022P\n\010SetRoles\022(.bgs.protocol.ch" + "annel.v1.SetRolesRequest\032\024.bgs.protocol." + "NoData\"\004\200\265\030\007\022b\n\021UnsubscribeMember\0221.bgs." + "protocol.channel.v1.UnsubscribeMemberReq" + "uest\032\024.bgs.protocol.NoData\"\004\200\265\030\010\032 \312>\035bne" + "t.protocol.channel.Channel2\375\005\n\017ChannelLi" + "stener\022T\n\006OnJoin\022).bgs.protocol.channel." + "v1.JoinNotification\032\031.bgs.protocol.NO_RE" + "SPONSE\"\004\200\265\030\001\022b\n\rOnMemberAdded\0220.bgs.prot" + "ocol.channel.v1.MemberAddedNotification\032" + "\031.bgs.protocol.NO_RESPONSE\"\004\200\265\030\002\022V\n\007OnLe" + "ave\022*.bgs.protocol.channel.v1.LeaveNotif" + "ication\032\031.bgs.protocol.NO_RESPONSE\"\004\200\265\030\003" + "\022f\n\017OnMemberRemoved\0222.bgs.protocol.chann" + "el.v1.MemberRemovedNotification\032\031.bgs.pr" + "otocol.NO_RESPONSE\"\004\200\265\030\004\022b\n\rOnSendMessag" + "e\0220.bgs.protocol.channel.v1.SendMessageN" + "otification\032\031.bgs.protocol.NO_RESPONSE\"\004" + "\200\265\030\005\022p\n\024OnUpdateChannelState\0227.bgs.proto" + "col.channel.v1.UpdateChannelStateNotific" + "ation\032\031.bgs.protocol.NO_RESPONSE\"\004\200\265\030\006\022n" + "\n\023OnUpdateMemberState\0226.bgs.protocol.cha" + "nnel.v1.UpdateMemberStateNotification\032\031." + "bgs.protocol.NO_RESPONSE\"\004\200\265\030\007\032*\312>\'bnet." + "protocol.channel.ChannelSubscriberB\005H\001\200\001" + "\000", 4521); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "channel_service.proto", &protobuf_RegisterTypes); + AddMemberRequest::default_instance_ = new AddMemberRequest(); + RemoveMemberRequest::default_instance_ = new RemoveMemberRequest(); + UnsubscribeMemberRequest::default_instance_ = new UnsubscribeMemberRequest(); + SendMessageRequest::default_instance_ = new SendMessageRequest(); + UpdateChannelStateRequest::default_instance_ = new UpdateChannelStateRequest(); + UpdateMemberStateRequest::default_instance_ = new UpdateMemberStateRequest(); + DissolveRequest::default_instance_ = new DissolveRequest(); + SetRolesRequest::default_instance_ = new SetRolesRequest(); + JoinNotification::default_instance_ = new JoinNotification(); + MemberAddedNotification::default_instance_ = new MemberAddedNotification(); + LeaveNotification::default_instance_ = new LeaveNotification(); + MemberRemovedNotification::default_instance_ = new MemberRemovedNotification(); + SendMessageNotification::default_instance_ = new SendMessageNotification(); + UpdateChannelStateNotification::default_instance_ = new UpdateChannelStateNotification(); + UpdateMemberStateNotification::default_instance_ = new UpdateMemberStateNotification(); + AddMemberRequest::default_instance_->InitAsDefaultInstance(); + RemoveMemberRequest::default_instance_->InitAsDefaultInstance(); + UnsubscribeMemberRequest::default_instance_->InitAsDefaultInstance(); + SendMessageRequest::default_instance_->InitAsDefaultInstance(); + UpdateChannelStateRequest::default_instance_->InitAsDefaultInstance(); + UpdateMemberStateRequest::default_instance_->InitAsDefaultInstance(); + DissolveRequest::default_instance_->InitAsDefaultInstance(); + SetRolesRequest::default_instance_->InitAsDefaultInstance(); + JoinNotification::default_instance_->InitAsDefaultInstance(); + MemberAddedNotification::default_instance_->InitAsDefaultInstance(); + LeaveNotification::default_instance_->InitAsDefaultInstance(); + MemberRemovedNotification::default_instance_->InitAsDefaultInstance(); + SendMessageNotification::default_instance_->InitAsDefaultInstance(); + UpdateChannelStateNotification::default_instance_->InitAsDefaultInstance(); + UpdateMemberStateNotification::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_channel_5fservice_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_channel_5fservice_2eproto { + StaticDescriptorInitializer_channel_5fservice_2eproto() { + protobuf_AddDesc_channel_5fservice_2eproto(); + } +} static_descriptor_initializer_channel_5fservice_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int AddMemberRequest::kAgentIdFieldNumber; +const int AddMemberRequest::kMemberIdentityFieldNumber; +const int AddMemberRequest::kMemberStateFieldNumber; +const int AddMemberRequest::kObjectIdFieldNumber; +const int AddMemberRequest::kSubscribeFieldNumber; +#endif // !_MSC_VER + +AddMemberRequest::AddMemberRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.AddMemberRequest) +} + +void AddMemberRequest::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + member_identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance()); + member_state_ = const_cast< ::bgs::protocol::channel::v1::MemberState*>(&::bgs::protocol::channel::v1::MemberState::default_instance()); +} + +AddMemberRequest::AddMemberRequest(const AddMemberRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.AddMemberRequest) +} + +void AddMemberRequest::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + member_identity_ = NULL; + member_state_ = NULL; + object_id_ = GOOGLE_ULONGLONG(0); + subscribe_ = true; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AddMemberRequest::~AddMemberRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.AddMemberRequest) + SharedDtor(); +} + +void AddMemberRequest::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + delete member_identity_; + delete member_state_; + } +} + +void AddMemberRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AddMemberRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AddMemberRequest_descriptor_; +} + +const AddMemberRequest& AddMemberRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto(); + return *default_instance_; +} + +AddMemberRequest* AddMemberRequest::default_instance_ = NULL; + +AddMemberRequest* AddMemberRequest::New() const { + return new AddMemberRequest; +} + +void AddMemberRequest::Clear() { + if (_has_bits_[0 / 32] & 31) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_member_identity()) { + if (member_identity_ != NULL) member_identity_->::bgs::protocol::Identity::Clear(); + } + if (has_member_state()) { + if (member_state_ != NULL) member_state_->::bgs::protocol::channel::v1::MemberState::Clear(); + } + object_id_ = GOOGLE_ULONGLONG(0); + subscribe_ = true; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AddMemberRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.AddMemberRequest) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_member_identity; + break; + } + + // required .bgs.protocol.Identity member_identity = 2; + case 2: { + if (tag == 18) { + parse_member_identity: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_member_identity())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_member_state; + break; + } + + // required .bgs.protocol.channel.v1.MemberState member_state = 3; + case 3: { + if (tag == 26) { + parse_member_state: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_member_state())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_object_id; + break; + } + + // required uint64 object_id = 4; + case 4: { + if (tag == 32) { + parse_object_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &object_id_))); + set_has_object_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_subscribe; + break; + } + + // optional bool subscribe = 5 [default = true]; + case 5: { + if (tag == 40) { + parse_subscribe: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &subscribe_))); + set_has_subscribe(); + } 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:bgs.protocol.channel.v1.AddMemberRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.AddMemberRequest) + return false; +#undef DO_ +} + +void AddMemberRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.AddMemberRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // required .bgs.protocol.Identity member_identity = 2; + if (has_member_identity()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->member_identity(), output); + } + + // required .bgs.protocol.channel.v1.MemberState member_state = 3; + if (has_member_state()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->member_state(), output); + } + + // required uint64 object_id = 4; + if (has_object_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->object_id(), output); + } + + // optional bool subscribe = 5 [default = true]; + if (has_subscribe()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->subscribe(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.AddMemberRequest) +} + +::google::protobuf::uint8* AddMemberRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.AddMemberRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // required .bgs.protocol.Identity member_identity = 2; + if (has_member_identity()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->member_identity(), target); + } + + // required .bgs.protocol.channel.v1.MemberState member_state = 3; + if (has_member_state()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->member_state(), target); + } + + // required uint64 object_id = 4; + if (has_object_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->object_id(), target); + } + + // optional bool subscribe = 5 [default = true]; + if (has_subscribe()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->subscribe(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.AddMemberRequest) + return target; +} + +int AddMemberRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // required .bgs.protocol.Identity member_identity = 2; + if (has_member_identity()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->member_identity()); + } + + // required .bgs.protocol.channel.v1.MemberState member_state = 3; + if (has_member_state()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->member_state()); + } + + // required uint64 object_id = 4; + if (has_object_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->object_id()); + } + + // optional bool subscribe = 5 [default = true]; + if (has_subscribe()) { + 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 AddMemberRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AddMemberRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AddMemberRequest::MergeFrom(const AddMemberRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_member_identity()) { + mutable_member_identity()->::bgs::protocol::Identity::MergeFrom(from.member_identity()); + } + if (from.has_member_state()) { + mutable_member_state()->::bgs::protocol::channel::v1::MemberState::MergeFrom(from.member_state()); + } + if (from.has_object_id()) { + set_object_id(from.object_id()); + } + if (from.has_subscribe()) { + set_subscribe(from.subscribe()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AddMemberRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AddMemberRequest::CopyFrom(const AddMemberRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AddMemberRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x0000000e) != 0x0000000e) return false; + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + if (has_member_identity()) { + if (!this->member_identity().IsInitialized()) return false; + } + if (has_member_state()) { + if (!this->member_state().IsInitialized()) return false; + } + return true; +} + +void AddMemberRequest::Swap(AddMemberRequest* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + std::swap(member_identity_, other->member_identity_); + std::swap(member_state_, other->member_state_); + std::swap(object_id_, other->object_id_); + std::swap(subscribe_, other->subscribe_); + 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 AddMemberRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AddMemberRequest_descriptor_; + metadata.reflection = AddMemberRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int RemoveMemberRequest::kAgentIdFieldNumber; +const int RemoveMemberRequest::kMemberIdFieldNumber; +const int RemoveMemberRequest::kReasonFieldNumber; +#endif // !_MSC_VER + +RemoveMemberRequest::RemoveMemberRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.RemoveMemberRequest) +} + +void RemoveMemberRequest::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + member_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +RemoveMemberRequest::RemoveMemberRequest(const RemoveMemberRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.RemoveMemberRequest) +} + +void RemoveMemberRequest::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + member_id_ = NULL; + reason_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +RemoveMemberRequest::~RemoveMemberRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.RemoveMemberRequest) + SharedDtor(); +} + +void RemoveMemberRequest::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + delete member_id_; + } +} + +void RemoveMemberRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* RemoveMemberRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return RemoveMemberRequest_descriptor_; +} + +const RemoveMemberRequest& RemoveMemberRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto(); + return *default_instance_; +} + +RemoveMemberRequest* RemoveMemberRequest::default_instance_ = NULL; + +RemoveMemberRequest* RemoveMemberRequest::New() const { + return new RemoveMemberRequest; +} + +void RemoveMemberRequest::Clear() { + if (_has_bits_[0 / 32] & 7) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_member_id()) { + if (member_id_ != NULL) member_id_->::bgs::protocol::EntityId::Clear(); + } + reason_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool RemoveMemberRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.RemoveMemberRequest) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_member_id; + break; + } + + // required .bgs.protocol.EntityId member_id = 2; + case 2: { + if (tag == 18) { + parse_member_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_member_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_reason; + break; + } + + // optional uint32 reason = 3; + case 3: { + if (tag == 24) { + parse_reason: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &reason_))); + set_has_reason(); + } 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:bgs.protocol.channel.v1.RemoveMemberRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.RemoveMemberRequest) + return false; +#undef DO_ +} + +void RemoveMemberRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.RemoveMemberRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // required .bgs.protocol.EntityId member_id = 2; + if (has_member_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->member_id(), output); + } + + // optional uint32 reason = 3; + if (has_reason()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->reason(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.RemoveMemberRequest) +} + +::google::protobuf::uint8* RemoveMemberRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.RemoveMemberRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // required .bgs.protocol.EntityId member_id = 2; + if (has_member_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->member_id(), target); + } + + // optional uint32 reason = 3; + if (has_reason()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->reason(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.RemoveMemberRequest) + return target; +} + +int RemoveMemberRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // required .bgs.protocol.EntityId member_id = 2; + if (has_member_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->member_id()); + } + + // optional uint32 reason = 3; + if (has_reason()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->reason()); + } + + } + 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 RemoveMemberRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const RemoveMemberRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void RemoveMemberRequest::MergeFrom(const RemoveMemberRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_member_id()) { + mutable_member_id()->::bgs::protocol::EntityId::MergeFrom(from.member_id()); + } + if (from.has_reason()) { + set_reason(from.reason()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void RemoveMemberRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RemoveMemberRequest::CopyFrom(const RemoveMemberRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RemoveMemberRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false; + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + if (has_member_id()) { + if (!this->member_id().IsInitialized()) return false; + } + return true; +} + +void RemoveMemberRequest::Swap(RemoveMemberRequest* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + std::swap(member_id_, other->member_id_); + std::swap(reason_, other->reason_); + 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 RemoveMemberRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = RemoveMemberRequest_descriptor_; + metadata.reflection = RemoveMemberRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int UnsubscribeMemberRequest::kAgentIdFieldNumber; +const int UnsubscribeMemberRequest::kMemberIdFieldNumber; +#endif // !_MSC_VER + +UnsubscribeMemberRequest::UnsubscribeMemberRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.UnsubscribeMemberRequest) +} + +void UnsubscribeMemberRequest::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + member_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +UnsubscribeMemberRequest::UnsubscribeMemberRequest(const UnsubscribeMemberRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.UnsubscribeMemberRequest) +} + +void UnsubscribeMemberRequest::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + member_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +UnsubscribeMemberRequest::~UnsubscribeMemberRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.UnsubscribeMemberRequest) + SharedDtor(); +} + +void UnsubscribeMemberRequest::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + delete member_id_; + } +} + +void UnsubscribeMemberRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* UnsubscribeMemberRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return UnsubscribeMemberRequest_descriptor_; +} + +const UnsubscribeMemberRequest& UnsubscribeMemberRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto(); + return *default_instance_; +} + +UnsubscribeMemberRequest* UnsubscribeMemberRequest::default_instance_ = NULL; + +UnsubscribeMemberRequest* UnsubscribeMemberRequest::New() const { + return new UnsubscribeMemberRequest; +} + +void UnsubscribeMemberRequest::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_member_id()) { + if (member_id_ != NULL) member_id_->::bgs::protocol::EntityId::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool UnsubscribeMemberRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.UnsubscribeMemberRequest) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_member_id; + break; + } + + // required .bgs.protocol.EntityId member_id = 2; + case 2: { + if (tag == 18) { + parse_member_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_member_id())); + } 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:bgs.protocol.channel.v1.UnsubscribeMemberRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.UnsubscribeMemberRequest) + return false; +#undef DO_ +} + +void UnsubscribeMemberRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.UnsubscribeMemberRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // required .bgs.protocol.EntityId member_id = 2; + if (has_member_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->member_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.UnsubscribeMemberRequest) +} + +::google::protobuf::uint8* UnsubscribeMemberRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.UnsubscribeMemberRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // required .bgs.protocol.EntityId member_id = 2; + if (has_member_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->member_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.UnsubscribeMemberRequest) + return target; +} + +int UnsubscribeMemberRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // required .bgs.protocol.EntityId member_id = 2; + if (has_member_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->member_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void UnsubscribeMemberRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const UnsubscribeMemberRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void UnsubscribeMemberRequest::MergeFrom(const UnsubscribeMemberRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_member_id()) { + mutable_member_id()->::bgs::protocol::EntityId::MergeFrom(from.member_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void UnsubscribeMemberRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void UnsubscribeMemberRequest::CopyFrom(const UnsubscribeMemberRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool UnsubscribeMemberRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false; + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + if (has_member_id()) { + if (!this->member_id().IsInitialized()) return false; + } + return true; +} + +void UnsubscribeMemberRequest::Swap(UnsubscribeMemberRequest* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + std::swap(member_id_, other->member_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata UnsubscribeMemberRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = UnsubscribeMemberRequest_descriptor_; + metadata.reflection = UnsubscribeMemberRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int SendMessageRequest::kAgentIdFieldNumber; +const int SendMessageRequest::kMessageFieldNumber; +const int SendMessageRequest::kRequiredPrivilegesFieldNumber; +#endif // !_MSC_VER + +SendMessageRequest::SendMessageRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.SendMessageRequest) +} + +void SendMessageRequest::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + message_ = const_cast< ::bgs::protocol::channel::v1::Message*>(&::bgs::protocol::channel::v1::Message::default_instance()); +} + +SendMessageRequest::SendMessageRequest(const SendMessageRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.SendMessageRequest) +} + +void SendMessageRequest::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + message_ = NULL; + required_privileges_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +SendMessageRequest::~SendMessageRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.SendMessageRequest) + SharedDtor(); +} + +void SendMessageRequest::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + delete message_; + } +} + +void SendMessageRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SendMessageRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SendMessageRequest_descriptor_; +} + +const SendMessageRequest& SendMessageRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto(); + return *default_instance_; +} + +SendMessageRequest* SendMessageRequest::default_instance_ = NULL; + +SendMessageRequest* SendMessageRequest::New() const { + return new SendMessageRequest; +} + +void SendMessageRequest::Clear() { + if (_has_bits_[0 / 32] & 7) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_message()) { + if (message_ != NULL) message_->::bgs::protocol::channel::v1::Message::Clear(); + } + required_privileges_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool SendMessageRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.SendMessageRequest) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_message; + break; + } + + // required .bgs.protocol.channel.v1.Message message = 2; + case 2: { + if (tag == 18) { + parse_message: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_message())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_required_privileges; + break; + } + + // optional uint64 required_privileges = 3 [default = 0]; + case 3: { + if (tag == 24) { + parse_required_privileges: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &required_privileges_))); + set_has_required_privileges(); + } 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:bgs.protocol.channel.v1.SendMessageRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.SendMessageRequest) + return false; +#undef DO_ +} + +void SendMessageRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.SendMessageRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // required .bgs.protocol.channel.v1.Message message = 2; + if (has_message()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->message(), output); + } + + // optional uint64 required_privileges = 3 [default = 0]; + if (has_required_privileges()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->required_privileges(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.SendMessageRequest) +} + +::google::protobuf::uint8* SendMessageRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.SendMessageRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // required .bgs.protocol.channel.v1.Message message = 2; + if (has_message()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->message(), target); + } + + // optional uint64 required_privileges = 3 [default = 0]; + if (has_required_privileges()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->required_privileges(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.SendMessageRequest) + return target; +} + +int SendMessageRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // required .bgs.protocol.channel.v1.Message message = 2; + if (has_message()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->message()); + } + + // optional uint64 required_privileges = 3 [default = 0]; + if (has_required_privileges()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->required_privileges()); + } + + } + 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 SendMessageRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const SendMessageRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void SendMessageRequest::MergeFrom(const SendMessageRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_message()) { + mutable_message()->::bgs::protocol::channel::v1::Message::MergeFrom(from.message()); + } + if (from.has_required_privileges()) { + set_required_privileges(from.required_privileges()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void SendMessageRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SendMessageRequest::CopyFrom(const SendMessageRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SendMessageRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false; + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + if (has_message()) { + if (!this->message().IsInitialized()) return false; + } + return true; +} + +void SendMessageRequest::Swap(SendMessageRequest* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + std::swap(message_, other->message_); + std::swap(required_privileges_, other->required_privileges_); + 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 SendMessageRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SendMessageRequest_descriptor_; + metadata.reflection = SendMessageRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int UpdateChannelStateRequest::kAgentIdFieldNumber; +const int UpdateChannelStateRequest::kStateChangeFieldNumber; +#endif // !_MSC_VER + +UpdateChannelStateRequest::UpdateChannelStateRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.UpdateChannelStateRequest) +} + +void UpdateChannelStateRequest::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + state_change_ = const_cast< ::bgs::protocol::channel::v1::ChannelState*>(&::bgs::protocol::channel::v1::ChannelState::default_instance()); +} + +UpdateChannelStateRequest::UpdateChannelStateRequest(const UpdateChannelStateRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.UpdateChannelStateRequest) +} + +void UpdateChannelStateRequest::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + state_change_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +UpdateChannelStateRequest::~UpdateChannelStateRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.UpdateChannelStateRequest) + SharedDtor(); +} + +void UpdateChannelStateRequest::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + delete state_change_; + } +} + +void UpdateChannelStateRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* UpdateChannelStateRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return UpdateChannelStateRequest_descriptor_; +} + +const UpdateChannelStateRequest& UpdateChannelStateRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto(); + return *default_instance_; +} + +UpdateChannelStateRequest* UpdateChannelStateRequest::default_instance_ = NULL; + +UpdateChannelStateRequest* UpdateChannelStateRequest::New() const { + return new UpdateChannelStateRequest; +} + +void UpdateChannelStateRequest::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_state_change()) { + if (state_change_ != NULL) state_change_->::bgs::protocol::channel::v1::ChannelState::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool UpdateChannelStateRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.UpdateChannelStateRequest) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_state_change; + break; + } + + // required .bgs.protocol.channel.v1.ChannelState state_change = 2; + case 2: { + if (tag == 18) { + parse_state_change: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_state_change())); + } 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:bgs.protocol.channel.v1.UpdateChannelStateRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.UpdateChannelStateRequest) + return false; +#undef DO_ +} + +void UpdateChannelStateRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.UpdateChannelStateRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // required .bgs.protocol.channel.v1.ChannelState state_change = 2; + if (has_state_change()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->state_change(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.UpdateChannelStateRequest) +} + +::google::protobuf::uint8* UpdateChannelStateRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.UpdateChannelStateRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // required .bgs.protocol.channel.v1.ChannelState state_change = 2; + if (has_state_change()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->state_change(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.UpdateChannelStateRequest) + return target; +} + +int UpdateChannelStateRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // required .bgs.protocol.channel.v1.ChannelState state_change = 2; + if (has_state_change()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->state_change()); + } + + } + 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 UpdateChannelStateRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const UpdateChannelStateRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void UpdateChannelStateRequest::MergeFrom(const UpdateChannelStateRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_state_change()) { + mutable_state_change()->::bgs::protocol::channel::v1::ChannelState::MergeFrom(from.state_change()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void UpdateChannelStateRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void UpdateChannelStateRequest::CopyFrom(const UpdateChannelStateRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool UpdateChannelStateRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false; + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + if (has_state_change()) { + if (!this->state_change().IsInitialized()) return false; + } + return true; +} + +void UpdateChannelStateRequest::Swap(UpdateChannelStateRequest* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + std::swap(state_change_, other->state_change_); + 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 UpdateChannelStateRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = UpdateChannelStateRequest_descriptor_; + metadata.reflection = UpdateChannelStateRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int UpdateMemberStateRequest::kAgentIdFieldNumber; +const int UpdateMemberStateRequest::kStateChangeFieldNumber; +const int UpdateMemberStateRequest::kRemovedRoleFieldNumber; +#endif // !_MSC_VER + +UpdateMemberStateRequest::UpdateMemberStateRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.UpdateMemberStateRequest) +} + +void UpdateMemberStateRequest::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +UpdateMemberStateRequest::UpdateMemberStateRequest(const UpdateMemberStateRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.UpdateMemberStateRequest) +} + +void UpdateMemberStateRequest::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +UpdateMemberStateRequest::~UpdateMemberStateRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.UpdateMemberStateRequest) + SharedDtor(); +} + +void UpdateMemberStateRequest::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + } +} + +void UpdateMemberStateRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* UpdateMemberStateRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return UpdateMemberStateRequest_descriptor_; +} + +const UpdateMemberStateRequest& UpdateMemberStateRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto(); + return *default_instance_; +} + +UpdateMemberStateRequest* UpdateMemberStateRequest::default_instance_ = NULL; + +UpdateMemberStateRequest* UpdateMemberStateRequest::New() const { + return new UpdateMemberStateRequest; +} + +void UpdateMemberStateRequest::Clear() { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + state_change_.Clear(); + removed_role_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool UpdateMemberStateRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.UpdateMemberStateRequest) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_state_change; + break; + } + + // repeated .bgs.protocol.channel.v1.Member state_change = 2; + case 2: { + if (tag == 18) { + parse_state_change: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_state_change())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_state_change; + if (input->ExpectTag(26)) goto parse_removed_role; + break; + } + + // repeated uint32 removed_role = 3 [packed = true]; + case 3: { + if (tag == 26) { + parse_removed_role: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_removed_role()))); + } else if (tag == 24) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 26, input, this->mutable_removed_role()))); + } 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:bgs.protocol.channel.v1.UpdateMemberStateRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.UpdateMemberStateRequest) + return false; +#undef DO_ +} + +void UpdateMemberStateRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.UpdateMemberStateRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // repeated .bgs.protocol.channel.v1.Member state_change = 2; + for (int i = 0; i < this->state_change_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->state_change(i), output); + } + + // repeated uint32 removed_role = 3 [packed = true]; + if (this->removed_role_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(3, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_removed_role_cached_byte_size_); + } + for (int i = 0; i < this->removed_role_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag( + this->removed_role(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.UpdateMemberStateRequest) +} + +::google::protobuf::uint8* UpdateMemberStateRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.UpdateMemberStateRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // repeated .bgs.protocol.channel.v1.Member state_change = 2; + for (int i = 0; i < this->state_change_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->state_change(i), target); + } + + // repeated uint32 removed_role = 3 [packed = true]; + if (this->removed_role_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 3, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _removed_role_cached_byte_size_, target); + } + for (int i = 0; i < this->removed_role_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32NoTagToArray(this->removed_role(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.UpdateMemberStateRequest) + return target; +} + +int UpdateMemberStateRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + } + // repeated .bgs.protocol.channel.v1.Member state_change = 2; + total_size += 1 * this->state_change_size(); + for (int i = 0; i < this->state_change_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->state_change(i)); + } + + // repeated uint32 removed_role = 3 [packed = true]; + { + int data_size = 0; + for (int i = 0; i < this->removed_role_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->removed_role(i)); + } + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _removed_role_cached_byte_size_ = data_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_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 UpdateMemberStateRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const UpdateMemberStateRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void UpdateMemberStateRequest::MergeFrom(const UpdateMemberStateRequest& from) { + GOOGLE_CHECK_NE(&from, this); + state_change_.MergeFrom(from.state_change_); + removed_role_.MergeFrom(from.removed_role_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void UpdateMemberStateRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void UpdateMemberStateRequest::CopyFrom(const UpdateMemberStateRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool UpdateMemberStateRequest::IsInitialized() const { + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + if (!::google::protobuf::internal::AllAreInitialized(this->state_change())) return false; + return true; +} + +void UpdateMemberStateRequest::Swap(UpdateMemberStateRequest* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + state_change_.Swap(&other->state_change_); + removed_role_.Swap(&other->removed_role_); + 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 UpdateMemberStateRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = UpdateMemberStateRequest_descriptor_; + metadata.reflection = UpdateMemberStateRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int DissolveRequest::kAgentIdFieldNumber; +const int DissolveRequest::kReasonFieldNumber; +#endif // !_MSC_VER + +DissolveRequest::DissolveRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.DissolveRequest) +} + +void DissolveRequest::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +DissolveRequest::DissolveRequest(const DissolveRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.DissolveRequest) +} + +void DissolveRequest::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + reason_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +DissolveRequest::~DissolveRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.DissolveRequest) + SharedDtor(); +} + +void DissolveRequest::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + } +} + +void DissolveRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* DissolveRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return DissolveRequest_descriptor_; +} + +const DissolveRequest& DissolveRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto(); + return *default_instance_; +} + +DissolveRequest* DissolveRequest::default_instance_ = NULL; + +DissolveRequest* DissolveRequest::New() const { + return new DissolveRequest; +} + +void DissolveRequest::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + reason_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool DissolveRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.DissolveRequest) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_reason; + break; + } + + // optional uint32 reason = 2; + case 2: { + if (tag == 16) { + parse_reason: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &reason_))); + set_has_reason(); + } 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:bgs.protocol.channel.v1.DissolveRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.DissolveRequest) + return false; +#undef DO_ +} + +void DissolveRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.DissolveRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // optional uint32 reason = 2; + if (has_reason()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->reason(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.DissolveRequest) +} + +::google::protobuf::uint8* DissolveRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.DissolveRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // optional uint32 reason = 2; + if (has_reason()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->reason(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.DissolveRequest) + return target; +} + +int DissolveRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // optional uint32 reason = 2; + if (has_reason()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->reason()); + } + + } + 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 DissolveRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const DissolveRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void DissolveRequest::MergeFrom(const DissolveRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_reason()) { + set_reason(from.reason()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void DissolveRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DissolveRequest::CopyFrom(const DissolveRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DissolveRequest::IsInitialized() const { + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + return true; +} + +void DissolveRequest::Swap(DissolveRequest* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + std::swap(reason_, other->reason_); + 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 DissolveRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = DissolveRequest_descriptor_; + metadata.reflection = DissolveRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int SetRolesRequest::kAgentIdFieldNumber; +const int SetRolesRequest::kRoleFieldNumber; +const int SetRolesRequest::kMemberIdFieldNumber; +#endif // !_MSC_VER + +SetRolesRequest::SetRolesRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.SetRolesRequest) +} + +void SetRolesRequest::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +SetRolesRequest::SetRolesRequest(const SetRolesRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.SetRolesRequest) +} + +void SetRolesRequest::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +SetRolesRequest::~SetRolesRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.SetRolesRequest) + SharedDtor(); +} + +void SetRolesRequest::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + } +} + +void SetRolesRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SetRolesRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SetRolesRequest_descriptor_; +} + +const SetRolesRequest& SetRolesRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto(); + return *default_instance_; +} + +SetRolesRequest* SetRolesRequest::default_instance_ = NULL; + +SetRolesRequest* SetRolesRequest::New() const { + return new SetRolesRequest; +} + +void SetRolesRequest::Clear() { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + role_.Clear(); + member_id_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool SetRolesRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.SetRolesRequest) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_role; + break; + } + + // repeated uint32 role = 2 [packed = true]; + case 2: { + if (tag == 18) { + parse_role: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_role()))); + } else if (tag == 16) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 18, input, this->mutable_role()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_member_id; + break; + } + + // repeated .bgs.protocol.EntityId member_id = 3; + case 3: { + if (tag == 26) { + parse_member_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_member_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_member_id; + 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:bgs.protocol.channel.v1.SetRolesRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.SetRolesRequest) + return false; +#undef DO_ +} + +void SetRolesRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.SetRolesRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // repeated uint32 role = 2 [packed = true]; + if (this->role_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(2, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_role_cached_byte_size_); + } + for (int i = 0; i < this->role_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag( + this->role(i), output); + } + + // repeated .bgs.protocol.EntityId member_id = 3; + for (int i = 0; i < this->member_id_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->member_id(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.SetRolesRequest) +} + +::google::protobuf::uint8* SetRolesRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.SetRolesRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // repeated uint32 role = 2 [packed = true]; + if (this->role_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 2, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _role_cached_byte_size_, target); + } + for (int i = 0; i < this->role_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32NoTagToArray(this->role(i), target); + } + + // repeated .bgs.protocol.EntityId member_id = 3; + for (int i = 0; i < this->member_id_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->member_id(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.SetRolesRequest) + return target; +} + +int SetRolesRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + } + // repeated uint32 role = 2 [packed = true]; + { + int data_size = 0; + for (int i = 0; i < this->role_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->role(i)); + } + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _role_cached_byte_size_ = data_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + // repeated .bgs.protocol.EntityId member_id = 3; + total_size += 1 * this->member_id_size(); + for (int i = 0; i < this->member_id_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->member_id(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 SetRolesRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const SetRolesRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void SetRolesRequest::MergeFrom(const SetRolesRequest& from) { + GOOGLE_CHECK_NE(&from, this); + role_.MergeFrom(from.role_); + member_id_.MergeFrom(from.member_id_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void SetRolesRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SetRolesRequest::CopyFrom(const SetRolesRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SetRolesRequest::IsInitialized() const { + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + if (!::google::protobuf::internal::AllAreInitialized(this->member_id())) return false; + return true; +} + +void SetRolesRequest::Swap(SetRolesRequest* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + role_.Swap(&other->role_); + member_id_.Swap(&other->member_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata SetRolesRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SetRolesRequest_descriptor_; + metadata.reflection = SetRolesRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int JoinNotification::kSelfFieldNumber; +const int JoinNotification::kMemberFieldNumber; +const int JoinNotification::kChannelStateFieldNumber; +const int JoinNotification::kChannelIdFieldNumber; +const int JoinNotification::kSubscriberFieldNumber; +#endif // !_MSC_VER + +JoinNotification::JoinNotification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.JoinNotification) +} + +void JoinNotification::InitAsDefaultInstance() { + self_ = const_cast< ::bgs::protocol::channel::v1::Member*>(&::bgs::protocol::channel::v1::Member::default_instance()); + channel_state_ = const_cast< ::bgs::protocol::channel::v1::ChannelState*>(&::bgs::protocol::channel::v1::ChannelState::default_instance()); + channel_id_ = const_cast< ::bgs::protocol::channel::v1::ChannelId*>(&::bgs::protocol::channel::v1::ChannelId::default_instance()); + subscriber_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance()); +} + +JoinNotification::JoinNotification(const JoinNotification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.JoinNotification) +} + +void JoinNotification::SharedCtor() { + _cached_size_ = 0; + self_ = NULL; + channel_state_ = NULL; + channel_id_ = NULL; + subscriber_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +JoinNotification::~JoinNotification() { + // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.JoinNotification) + SharedDtor(); +} + +void JoinNotification::SharedDtor() { + if (this != default_instance_) { + delete self_; + delete channel_state_; + delete channel_id_; + delete subscriber_; + } +} + +void JoinNotification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* JoinNotification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return JoinNotification_descriptor_; +} + +const JoinNotification& JoinNotification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto(); + return *default_instance_; +} + +JoinNotification* JoinNotification::default_instance_ = NULL; + +JoinNotification* JoinNotification::New() const { + return new JoinNotification; +} + +void JoinNotification::Clear() { + if (_has_bits_[0 / 32] & 29) { + if (has_self()) { + if (self_ != NULL) self_->::bgs::protocol::channel::v1::Member::Clear(); + } + if (has_channel_state()) { + if (channel_state_ != NULL) channel_state_->::bgs::protocol::channel::v1::ChannelState::Clear(); + } + if (has_channel_id()) { + if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear(); + } + if (has_subscriber()) { + if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear(); + } + } + member_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool JoinNotification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.JoinNotification) + 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 .bgs.protocol.channel.v1.Member self = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_self())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_member; + break; + } + + // repeated .bgs.protocol.channel.v1.Member member = 2; + case 2: { + if (tag == 18) { + parse_member: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_member())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_member; + if (input->ExpectTag(26)) goto parse_channel_state; + break; + } + + // required .bgs.protocol.channel.v1.ChannelState channel_state = 3; + case 3: { + if (tag == 26) { + parse_channel_state: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_channel_state())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_channel_id; + break; + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4; + case 4: { + if (tag == 34) { + parse_channel_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_channel_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_subscriber; + break; + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 5; + case 5: { + if (tag == 42) { + parse_subscriber: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_subscriber())); + } 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:bgs.protocol.channel.v1.JoinNotification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.JoinNotification) + return false; +#undef DO_ +} + +void JoinNotification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.JoinNotification) + // optional .bgs.protocol.channel.v1.Member self = 1; + if (has_self()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->self(), output); + } + + // repeated .bgs.protocol.channel.v1.Member member = 2; + for (int i = 0; i < this->member_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->member(i), output); + } + + // required .bgs.protocol.channel.v1.ChannelState channel_state = 3; + if (has_channel_state()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->channel_state(), output); + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4; + if (has_channel_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->channel_id(), output); + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 5; + if (has_subscriber()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, this->subscriber(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.JoinNotification) +} + +::google::protobuf::uint8* JoinNotification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.JoinNotification) + // optional .bgs.protocol.channel.v1.Member self = 1; + if (has_self()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->self(), target); + } + + // repeated .bgs.protocol.channel.v1.Member member = 2; + for (int i = 0; i < this->member_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->member(i), target); + } + + // required .bgs.protocol.channel.v1.ChannelState channel_state = 3; + if (has_channel_state()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->channel_state(), target); + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4; + if (has_channel_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->channel_id(), target); + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 5; + if (has_subscriber()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 5, this->subscriber(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.JoinNotification) + return target; +} + +int JoinNotification::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.channel.v1.Member self = 1; + if (has_self()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->self()); + } + + // required .bgs.protocol.channel.v1.ChannelState channel_state = 3; + if (has_channel_state()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->channel_state()); + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4; + if (has_channel_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->channel_id()); + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 5; + if (has_subscriber()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->subscriber()); + } + + } + // repeated .bgs.protocol.channel.v1.Member member = 2; + total_size += 1 * this->member_size(); + for (int i = 0; i < this->member_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->member(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 JoinNotification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const JoinNotification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void JoinNotification::MergeFrom(const JoinNotification& from) { + GOOGLE_CHECK_NE(&from, this); + member_.MergeFrom(from.member_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_self()) { + mutable_self()->::bgs::protocol::channel::v1::Member::MergeFrom(from.self()); + } + if (from.has_channel_state()) { + mutable_channel_state()->::bgs::protocol::channel::v1::ChannelState::MergeFrom(from.channel_state()); + } + if (from.has_channel_id()) { + mutable_channel_id()->::bgs::protocol::channel::v1::ChannelId::MergeFrom(from.channel_id()); + } + if (from.has_subscriber()) { + mutable_subscriber()->::bgs::protocol::account::v1::Identity::MergeFrom(from.subscriber()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void JoinNotification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void JoinNotification::CopyFrom(const JoinNotification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool JoinNotification::IsInitialized() const { + if ((_has_bits_[0] & 0x00000004) != 0x00000004) return false; + + if (has_self()) { + if (!this->self().IsInitialized()) return false; + } + if (!::google::protobuf::internal::AllAreInitialized(this->member())) return false; + if (has_channel_state()) { + if (!this->channel_state().IsInitialized()) return false; + } + if (has_channel_id()) { + if (!this->channel_id().IsInitialized()) return false; + } + if (has_subscriber()) { + if (!this->subscriber().IsInitialized()) return false; + } + return true; +} + +void JoinNotification::Swap(JoinNotification* other) { + if (other != this) { + std::swap(self_, other->self_); + member_.Swap(&other->member_); + std::swap(channel_state_, other->channel_state_); + std::swap(channel_id_, other->channel_id_); + std::swap(subscriber_, other->subscriber_); + 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 JoinNotification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = JoinNotification_descriptor_; + metadata.reflection = JoinNotification_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int MemberAddedNotification::kMemberFieldNumber; +const int MemberAddedNotification::kChannelIdFieldNumber; +const int MemberAddedNotification::kSubscriberFieldNumber; +#endif // !_MSC_VER + +MemberAddedNotification::MemberAddedNotification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.MemberAddedNotification) +} + +void MemberAddedNotification::InitAsDefaultInstance() { + member_ = const_cast< ::bgs::protocol::channel::v1::Member*>(&::bgs::protocol::channel::v1::Member::default_instance()); + channel_id_ = const_cast< ::bgs::protocol::channel::v1::ChannelId*>(&::bgs::protocol::channel::v1::ChannelId::default_instance()); + subscriber_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance()); +} + +MemberAddedNotification::MemberAddedNotification(const MemberAddedNotification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.MemberAddedNotification) +} + +void MemberAddedNotification::SharedCtor() { + _cached_size_ = 0; + member_ = NULL; + channel_id_ = NULL; + subscriber_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +MemberAddedNotification::~MemberAddedNotification() { + // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.MemberAddedNotification) + SharedDtor(); +} + +void MemberAddedNotification::SharedDtor() { + if (this != default_instance_) { + delete member_; + delete channel_id_; + delete subscriber_; + } +} + +void MemberAddedNotification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* MemberAddedNotification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return MemberAddedNotification_descriptor_; +} + +const MemberAddedNotification& MemberAddedNotification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto(); + return *default_instance_; +} + +MemberAddedNotification* MemberAddedNotification::default_instance_ = NULL; + +MemberAddedNotification* MemberAddedNotification::New() const { + return new MemberAddedNotification; +} + +void MemberAddedNotification::Clear() { + if (_has_bits_[0 / 32] & 7) { + if (has_member()) { + if (member_ != NULL) member_->::bgs::protocol::channel::v1::Member::Clear(); + } + if (has_channel_id()) { + if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear(); + } + if (has_subscriber()) { + if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool MemberAddedNotification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.MemberAddedNotification) + 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)) { + // required .bgs.protocol.channel.v1.Member member = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_member())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_channel_id; + break; + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 2; + case 2: { + if (tag == 18) { + parse_channel_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_channel_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_subscriber; + break; + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 3; + case 3: { + if (tag == 26) { + parse_subscriber: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_subscriber())); + } 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:bgs.protocol.channel.v1.MemberAddedNotification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.MemberAddedNotification) + return false; +#undef DO_ +} + +void MemberAddedNotification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.MemberAddedNotification) + // required .bgs.protocol.channel.v1.Member member = 1; + if (has_member()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->member(), output); + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 2; + if (has_channel_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->channel_id(), output); + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 3; + if (has_subscriber()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->subscriber(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.MemberAddedNotification) +} + +::google::protobuf::uint8* MemberAddedNotification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.MemberAddedNotification) + // required .bgs.protocol.channel.v1.Member member = 1; + if (has_member()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->member(), target); + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 2; + if (has_channel_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->channel_id(), target); + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 3; + if (has_subscriber()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->subscriber(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.MemberAddedNotification) + return target; +} + +int MemberAddedNotification::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.channel.v1.Member member = 1; + if (has_member()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->member()); + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 2; + if (has_channel_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->channel_id()); + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 3; + if (has_subscriber()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->subscriber()); + } + + } + 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 MemberAddedNotification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const MemberAddedNotification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void MemberAddedNotification::MergeFrom(const MemberAddedNotification& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_member()) { + mutable_member()->::bgs::protocol::channel::v1::Member::MergeFrom(from.member()); + } + if (from.has_channel_id()) { + mutable_channel_id()->::bgs::protocol::channel::v1::ChannelId::MergeFrom(from.channel_id()); + } + if (from.has_subscriber()) { + mutable_subscriber()->::bgs::protocol::account::v1::Identity::MergeFrom(from.subscriber()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void MemberAddedNotification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MemberAddedNotification::CopyFrom(const MemberAddedNotification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MemberAddedNotification::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_member()) { + if (!this->member().IsInitialized()) return false; + } + if (has_channel_id()) { + if (!this->channel_id().IsInitialized()) return false; + } + if (has_subscriber()) { + if (!this->subscriber().IsInitialized()) return false; + } + return true; +} + +void MemberAddedNotification::Swap(MemberAddedNotification* other) { + if (other != this) { + std::swap(member_, other->member_); + std::swap(channel_id_, other->channel_id_); + std::swap(subscriber_, other->subscriber_); + 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 MemberAddedNotification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = MemberAddedNotification_descriptor_; + metadata.reflection = MemberAddedNotification_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int LeaveNotification::kAgentIdFieldNumber; +const int LeaveNotification::kMemberIdFieldNumber; +const int LeaveNotification::kReasonFieldNumber; +const int LeaveNotification::kChannelIdFieldNumber; +const int LeaveNotification::kSubscriberFieldNumber; +#endif // !_MSC_VER + +LeaveNotification::LeaveNotification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.LeaveNotification) +} + +void LeaveNotification::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + member_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + channel_id_ = const_cast< ::bgs::protocol::channel::v1::ChannelId*>(&::bgs::protocol::channel::v1::ChannelId::default_instance()); + subscriber_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance()); +} + +LeaveNotification::LeaveNotification(const LeaveNotification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.LeaveNotification) +} + +void LeaveNotification::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + member_id_ = NULL; + reason_ = 0u; + channel_id_ = NULL; + subscriber_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +LeaveNotification::~LeaveNotification() { + // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.LeaveNotification) + SharedDtor(); +} + +void LeaveNotification::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + delete member_id_; + delete channel_id_; + delete subscriber_; + } +} + +void LeaveNotification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* LeaveNotification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return LeaveNotification_descriptor_; +} + +const LeaveNotification& LeaveNotification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto(); + return *default_instance_; +} + +LeaveNotification* LeaveNotification::default_instance_ = NULL; + +LeaveNotification* LeaveNotification::New() const { + return new LeaveNotification; +} + +void LeaveNotification::Clear() { + if (_has_bits_[0 / 32] & 31) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_member_id()) { + if (member_id_ != NULL) member_id_->::bgs::protocol::EntityId::Clear(); + } + reason_ = 0u; + if (has_channel_id()) { + if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear(); + } + if (has_subscriber()) { + if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool LeaveNotification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.LeaveNotification) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_member_id; + break; + } + + // required .bgs.protocol.EntityId member_id = 2; + case 2: { + if (tag == 18) { + parse_member_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_member_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_reason; + break; + } + + // optional uint32 reason = 3; + case 3: { + if (tag == 24) { + parse_reason: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &reason_))); + set_has_reason(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_channel_id; + break; + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4; + case 4: { + if (tag == 34) { + parse_channel_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_channel_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_subscriber; + break; + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 5; + case 5: { + if (tag == 42) { + parse_subscriber: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_subscriber())); + } 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:bgs.protocol.channel.v1.LeaveNotification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.LeaveNotification) + return false; +#undef DO_ +} + +void LeaveNotification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.LeaveNotification) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // required .bgs.protocol.EntityId member_id = 2; + if (has_member_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->member_id(), output); + } + + // optional uint32 reason = 3; + if (has_reason()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->reason(), output); + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4; + if (has_channel_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->channel_id(), output); + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 5; + if (has_subscriber()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, this->subscriber(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.LeaveNotification) +} + +::google::protobuf::uint8* LeaveNotification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.LeaveNotification) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // required .bgs.protocol.EntityId member_id = 2; + if (has_member_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->member_id(), target); + } + + // optional uint32 reason = 3; + if (has_reason()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->reason(), target); + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4; + if (has_channel_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->channel_id(), target); + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 5; + if (has_subscriber()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 5, this->subscriber(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.LeaveNotification) + return target; +} + +int LeaveNotification::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // required .bgs.protocol.EntityId member_id = 2; + if (has_member_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->member_id()); + } + + // optional uint32 reason = 3; + if (has_reason()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->reason()); + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4; + if (has_channel_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->channel_id()); + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 5; + if (has_subscriber()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->subscriber()); + } + + } + 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 LeaveNotification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const LeaveNotification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void LeaveNotification::MergeFrom(const LeaveNotification& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_member_id()) { + mutable_member_id()->::bgs::protocol::EntityId::MergeFrom(from.member_id()); + } + if (from.has_reason()) { + set_reason(from.reason()); + } + if (from.has_channel_id()) { + mutable_channel_id()->::bgs::protocol::channel::v1::ChannelId::MergeFrom(from.channel_id()); + } + if (from.has_subscriber()) { + mutable_subscriber()->::bgs::protocol::account::v1::Identity::MergeFrom(from.subscriber()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void LeaveNotification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void LeaveNotification::CopyFrom(const LeaveNotification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool LeaveNotification::IsInitialized() const { + if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false; + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + if (has_member_id()) { + if (!this->member_id().IsInitialized()) return false; + } + if (has_channel_id()) { + if (!this->channel_id().IsInitialized()) return false; + } + if (has_subscriber()) { + if (!this->subscriber().IsInitialized()) return false; + } + return true; +} + +void LeaveNotification::Swap(LeaveNotification* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + std::swap(member_id_, other->member_id_); + std::swap(reason_, other->reason_); + std::swap(channel_id_, other->channel_id_); + std::swap(subscriber_, other->subscriber_); + 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 LeaveNotification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = LeaveNotification_descriptor_; + metadata.reflection = LeaveNotification_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int MemberRemovedNotification::kAgentIdFieldNumber; +const int MemberRemovedNotification::kMemberIdFieldNumber; +const int MemberRemovedNotification::kReasonFieldNumber; +const int MemberRemovedNotification::kChannelIdFieldNumber; +const int MemberRemovedNotification::kSubscriberFieldNumber; +#endif // !_MSC_VER + +MemberRemovedNotification::MemberRemovedNotification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.MemberRemovedNotification) +} + +void MemberRemovedNotification::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + member_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + channel_id_ = const_cast< ::bgs::protocol::channel::v1::ChannelId*>(&::bgs::protocol::channel::v1::ChannelId::default_instance()); + subscriber_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance()); +} + +MemberRemovedNotification::MemberRemovedNotification(const MemberRemovedNotification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.MemberRemovedNotification) +} + +void MemberRemovedNotification::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + member_id_ = NULL; + reason_ = 0u; + channel_id_ = NULL; + subscriber_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +MemberRemovedNotification::~MemberRemovedNotification() { + // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.MemberRemovedNotification) + SharedDtor(); +} + +void MemberRemovedNotification::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + delete member_id_; + delete channel_id_; + delete subscriber_; + } +} + +void MemberRemovedNotification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* MemberRemovedNotification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return MemberRemovedNotification_descriptor_; +} + +const MemberRemovedNotification& MemberRemovedNotification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto(); + return *default_instance_; +} + +MemberRemovedNotification* MemberRemovedNotification::default_instance_ = NULL; + +MemberRemovedNotification* MemberRemovedNotification::New() const { + return new MemberRemovedNotification; +} + +void MemberRemovedNotification::Clear() { + if (_has_bits_[0 / 32] & 31) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_member_id()) { + if (member_id_ != NULL) member_id_->::bgs::protocol::EntityId::Clear(); + } + reason_ = 0u; + if (has_channel_id()) { + if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear(); + } + if (has_subscriber()) { + if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool MemberRemovedNotification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.MemberRemovedNotification) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_member_id; + break; + } + + // required .bgs.protocol.EntityId member_id = 2; + case 2: { + if (tag == 18) { + parse_member_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_member_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_reason; + break; + } + + // optional uint32 reason = 3; + case 3: { + if (tag == 24) { + parse_reason: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &reason_))); + set_has_reason(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_channel_id; + break; + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4; + case 4: { + if (tag == 34) { + parse_channel_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_channel_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_subscriber; + break; + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 5; + case 5: { + if (tag == 42) { + parse_subscriber: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_subscriber())); + } 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:bgs.protocol.channel.v1.MemberRemovedNotification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.MemberRemovedNotification) + return false; +#undef DO_ +} + +void MemberRemovedNotification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.MemberRemovedNotification) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // required .bgs.protocol.EntityId member_id = 2; + if (has_member_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->member_id(), output); + } + + // optional uint32 reason = 3; + if (has_reason()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->reason(), output); + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4; + if (has_channel_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->channel_id(), output); + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 5; + if (has_subscriber()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, this->subscriber(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.MemberRemovedNotification) +} + +::google::protobuf::uint8* MemberRemovedNotification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.MemberRemovedNotification) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // required .bgs.protocol.EntityId member_id = 2; + if (has_member_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->member_id(), target); + } + + // optional uint32 reason = 3; + if (has_reason()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->reason(), target); + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4; + if (has_channel_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->channel_id(), target); + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 5; + if (has_subscriber()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 5, this->subscriber(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.MemberRemovedNotification) + return target; +} + +int MemberRemovedNotification::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // required .bgs.protocol.EntityId member_id = 2; + if (has_member_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->member_id()); + } + + // optional uint32 reason = 3; + if (has_reason()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->reason()); + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4; + if (has_channel_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->channel_id()); + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 5; + if (has_subscriber()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->subscriber()); + } + + } + 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 MemberRemovedNotification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const MemberRemovedNotification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void MemberRemovedNotification::MergeFrom(const MemberRemovedNotification& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_member_id()) { + mutable_member_id()->::bgs::protocol::EntityId::MergeFrom(from.member_id()); + } + if (from.has_reason()) { + set_reason(from.reason()); + } + if (from.has_channel_id()) { + mutable_channel_id()->::bgs::protocol::channel::v1::ChannelId::MergeFrom(from.channel_id()); + } + if (from.has_subscriber()) { + mutable_subscriber()->::bgs::protocol::account::v1::Identity::MergeFrom(from.subscriber()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void MemberRemovedNotification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MemberRemovedNotification::CopyFrom(const MemberRemovedNotification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MemberRemovedNotification::IsInitialized() const { + if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false; + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + if (has_member_id()) { + if (!this->member_id().IsInitialized()) return false; + } + if (has_channel_id()) { + if (!this->channel_id().IsInitialized()) return false; + } + if (has_subscriber()) { + if (!this->subscriber().IsInitialized()) return false; + } + return true; +} + +void MemberRemovedNotification::Swap(MemberRemovedNotification* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + std::swap(member_id_, other->member_id_); + std::swap(reason_, other->reason_); + std::swap(channel_id_, other->channel_id_); + std::swap(subscriber_, other->subscriber_); + 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 MemberRemovedNotification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = MemberRemovedNotification_descriptor_; + metadata.reflection = MemberRemovedNotification_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int SendMessageNotification::kAgentIdFieldNumber; +const int SendMessageNotification::kMessageFieldNumber; +const int SendMessageNotification::kRequiredPrivilegesFieldNumber; +const int SendMessageNotification::kIdentityFieldNumber; +const int SendMessageNotification::kChannelIdFieldNumber; +const int SendMessageNotification::kSubscriberFieldNumber; +#endif // !_MSC_VER + +SendMessageNotification::SendMessageNotification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.SendMessageNotification) +} + +void SendMessageNotification::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + message_ = const_cast< ::bgs::protocol::channel::v1::Message*>(&::bgs::protocol::channel::v1::Message::default_instance()); + channel_id_ = const_cast< ::bgs::protocol::channel::v1::ChannelId*>(&::bgs::protocol::channel::v1::ChannelId::default_instance()); + subscriber_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance()); +} + +SendMessageNotification::SendMessageNotification(const SendMessageNotification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.SendMessageNotification) +} + +void SendMessageNotification::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + agent_id_ = NULL; + message_ = NULL; + required_privileges_ = GOOGLE_ULONGLONG(0); + identity_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + channel_id_ = NULL; + subscriber_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +SendMessageNotification::~SendMessageNotification() { + // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.SendMessageNotification) + SharedDtor(); +} + +void SendMessageNotification::SharedDtor() { + if (identity_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete identity_; + } + if (this != default_instance_) { + delete agent_id_; + delete message_; + delete channel_id_; + delete subscriber_; + } +} + +void SendMessageNotification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SendMessageNotification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SendMessageNotification_descriptor_; +} + +const SendMessageNotification& SendMessageNotification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto(); + return *default_instance_; +} + +SendMessageNotification* SendMessageNotification::default_instance_ = NULL; + +SendMessageNotification* SendMessageNotification::New() const { + return new SendMessageNotification; +} + +void SendMessageNotification::Clear() { + if (_has_bits_[0 / 32] & 63) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_message()) { + if (message_ != NULL) message_->::bgs::protocol::channel::v1::Message::Clear(); + } + required_privileges_ = GOOGLE_ULONGLONG(0); + if (has_identity()) { + if (identity_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + identity_->clear(); + } + } + if (has_channel_id()) { + if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear(); + } + if (has_subscriber()) { + if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool SendMessageNotification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.SendMessageNotification) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_message; + break; + } + + // required .bgs.protocol.channel.v1.Message message = 2; + case 2: { + if (tag == 18) { + parse_message: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_message())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_required_privileges; + break; + } + + // optional uint64 required_privileges = 3 [default = 0]; + case 3: { + if (tag == 24) { + parse_required_privileges: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &required_privileges_))); + set_has_required_privileges(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_identity; + break; + } + + // optional string identity = 4; + case 4: { + if (tag == 34) { + parse_identity: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_identity())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->identity().data(), this->identity().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "identity"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_channel_id; + break; + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 5; + case 5: { + if (tag == 42) { + parse_channel_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_channel_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_subscriber; + break; + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 6; + case 6: { + if (tag == 50) { + parse_subscriber: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_subscriber())); + } 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:bgs.protocol.channel.v1.SendMessageNotification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.SendMessageNotification) + return false; +#undef DO_ +} + +void SendMessageNotification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.SendMessageNotification) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // required .bgs.protocol.channel.v1.Message message = 2; + if (has_message()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->message(), output); + } + + // optional uint64 required_privileges = 3 [default = 0]; + if (has_required_privileges()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->required_privileges(), output); + } + + // optional string identity = 4; + if (has_identity()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->identity().data(), this->identity().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "identity"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 4, this->identity(), output); + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 5; + if (has_channel_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, this->channel_id(), output); + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 6; + if (has_subscriber()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, this->subscriber(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.SendMessageNotification) +} + +::google::protobuf::uint8* SendMessageNotification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.SendMessageNotification) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // required .bgs.protocol.channel.v1.Message message = 2; + if (has_message()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->message(), target); + } + + // optional uint64 required_privileges = 3 [default = 0]; + if (has_required_privileges()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->required_privileges(), target); + } + + // optional string identity = 4; + if (has_identity()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->identity().data(), this->identity().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "identity"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->identity(), target); + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 5; + if (has_channel_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 5, this->channel_id(), target); + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 6; + if (has_subscriber()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 6, this->subscriber(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.SendMessageNotification) + return target; +} + +int SendMessageNotification::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // required .bgs.protocol.channel.v1.Message message = 2; + if (has_message()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->message()); + } + + // optional uint64 required_privileges = 3 [default = 0]; + if (has_required_privileges()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->required_privileges()); + } + + // optional string identity = 4; + if (has_identity()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->identity()); + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 5; + if (has_channel_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->channel_id()); + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 6; + if (has_subscriber()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->subscriber()); + } + + } + 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 SendMessageNotification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const SendMessageNotification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void SendMessageNotification::MergeFrom(const SendMessageNotification& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_message()) { + mutable_message()->::bgs::protocol::channel::v1::Message::MergeFrom(from.message()); + } + if (from.has_required_privileges()) { + set_required_privileges(from.required_privileges()); + } + if (from.has_identity()) { + set_identity(from.identity()); + } + if (from.has_channel_id()) { + mutable_channel_id()->::bgs::protocol::channel::v1::ChannelId::MergeFrom(from.channel_id()); + } + if (from.has_subscriber()) { + mutable_subscriber()->::bgs::protocol::account::v1::Identity::MergeFrom(from.subscriber()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void SendMessageNotification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SendMessageNotification::CopyFrom(const SendMessageNotification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SendMessageNotification::IsInitialized() const { + if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false; + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + if (has_message()) { + if (!this->message().IsInitialized()) return false; + } + if (has_channel_id()) { + if (!this->channel_id().IsInitialized()) return false; + } + if (has_subscriber()) { + if (!this->subscriber().IsInitialized()) return false; + } + return true; +} + +void SendMessageNotification::Swap(SendMessageNotification* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + std::swap(message_, other->message_); + std::swap(required_privileges_, other->required_privileges_); + std::swap(identity_, other->identity_); + std::swap(channel_id_, other->channel_id_); + std::swap(subscriber_, other->subscriber_); + 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 SendMessageNotification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SendMessageNotification_descriptor_; + metadata.reflection = SendMessageNotification_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int UpdateChannelStateNotification::kAgentIdFieldNumber; +const int UpdateChannelStateNotification::kStateChangeFieldNumber; +const int UpdateChannelStateNotification::kChannelIdFieldNumber; +const int UpdateChannelStateNotification::kSubscriberFieldNumber; +#endif // !_MSC_VER + +UpdateChannelStateNotification::UpdateChannelStateNotification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.UpdateChannelStateNotification) +} + +void UpdateChannelStateNotification::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + state_change_ = const_cast< ::bgs::protocol::channel::v1::ChannelState*>(&::bgs::protocol::channel::v1::ChannelState::default_instance()); + channel_id_ = const_cast< ::bgs::protocol::channel::v1::ChannelId*>(&::bgs::protocol::channel::v1::ChannelId::default_instance()); + subscriber_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance()); +} + +UpdateChannelStateNotification::UpdateChannelStateNotification(const UpdateChannelStateNotification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.UpdateChannelStateNotification) +} + +void UpdateChannelStateNotification::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + state_change_ = NULL; + channel_id_ = NULL; + subscriber_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +UpdateChannelStateNotification::~UpdateChannelStateNotification() { + // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.UpdateChannelStateNotification) + SharedDtor(); +} + +void UpdateChannelStateNotification::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + delete state_change_; + delete channel_id_; + delete subscriber_; + } +} + +void UpdateChannelStateNotification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* UpdateChannelStateNotification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return UpdateChannelStateNotification_descriptor_; +} + +const UpdateChannelStateNotification& UpdateChannelStateNotification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto(); + return *default_instance_; +} + +UpdateChannelStateNotification* UpdateChannelStateNotification::default_instance_ = NULL; + +UpdateChannelStateNotification* UpdateChannelStateNotification::New() const { + return new UpdateChannelStateNotification; +} + +void UpdateChannelStateNotification::Clear() { + if (_has_bits_[0 / 32] & 15) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_state_change()) { + if (state_change_ != NULL) state_change_->::bgs::protocol::channel::v1::ChannelState::Clear(); + } + if (has_channel_id()) { + if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear(); + } + if (has_subscriber()) { + if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool UpdateChannelStateNotification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.UpdateChannelStateNotification) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_state_change; + break; + } + + // required .bgs.protocol.channel.v1.ChannelState state_change = 2; + case 2: { + if (tag == 18) { + parse_state_change: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_state_change())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_channel_id; + break; + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 3; + case 3: { + if (tag == 26) { + parse_channel_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_channel_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_subscriber; + break; + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 4; + case 4: { + if (tag == 34) { + parse_subscriber: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_subscriber())); + } 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:bgs.protocol.channel.v1.UpdateChannelStateNotification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.UpdateChannelStateNotification) + return false; +#undef DO_ +} + +void UpdateChannelStateNotification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.UpdateChannelStateNotification) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // required .bgs.protocol.channel.v1.ChannelState state_change = 2; + if (has_state_change()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->state_change(), output); + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 3; + if (has_channel_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->channel_id(), output); + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 4; + if (has_subscriber()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->subscriber(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.UpdateChannelStateNotification) +} + +::google::protobuf::uint8* UpdateChannelStateNotification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.UpdateChannelStateNotification) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // required .bgs.protocol.channel.v1.ChannelState state_change = 2; + if (has_state_change()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->state_change(), target); + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 3; + if (has_channel_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->channel_id(), target); + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 4; + if (has_subscriber()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->subscriber(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.UpdateChannelStateNotification) + return target; +} + +int UpdateChannelStateNotification::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // required .bgs.protocol.channel.v1.ChannelState state_change = 2; + if (has_state_change()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->state_change()); + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 3; + if (has_channel_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->channel_id()); + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 4; + if (has_subscriber()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->subscriber()); + } + + } + 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 UpdateChannelStateNotification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const UpdateChannelStateNotification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void UpdateChannelStateNotification::MergeFrom(const UpdateChannelStateNotification& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_state_change()) { + mutable_state_change()->::bgs::protocol::channel::v1::ChannelState::MergeFrom(from.state_change()); + } + if (from.has_channel_id()) { + mutable_channel_id()->::bgs::protocol::channel::v1::ChannelId::MergeFrom(from.channel_id()); + } + if (from.has_subscriber()) { + mutable_subscriber()->::bgs::protocol::account::v1::Identity::MergeFrom(from.subscriber()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void UpdateChannelStateNotification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void UpdateChannelStateNotification::CopyFrom(const UpdateChannelStateNotification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool UpdateChannelStateNotification::IsInitialized() const { + if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false; + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + if (has_state_change()) { + if (!this->state_change().IsInitialized()) return false; + } + if (has_channel_id()) { + if (!this->channel_id().IsInitialized()) return false; + } + if (has_subscriber()) { + if (!this->subscriber().IsInitialized()) return false; + } + return true; +} + +void UpdateChannelStateNotification::Swap(UpdateChannelStateNotification* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + std::swap(state_change_, other->state_change_); + std::swap(channel_id_, other->channel_id_); + std::swap(subscriber_, other->subscriber_); + 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 UpdateChannelStateNotification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = UpdateChannelStateNotification_descriptor_; + metadata.reflection = UpdateChannelStateNotification_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int UpdateMemberStateNotification::kAgentIdFieldNumber; +const int UpdateMemberStateNotification::kStateChangeFieldNumber; +const int UpdateMemberStateNotification::kRemovedRoleFieldNumber; +const int UpdateMemberStateNotification::kChannelIdFieldNumber; +const int UpdateMemberStateNotification::kSubscriberFieldNumber; +#endif // !_MSC_VER + +UpdateMemberStateNotification::UpdateMemberStateNotification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.UpdateMemberStateNotification) +} + +void UpdateMemberStateNotification::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + channel_id_ = const_cast< ::bgs::protocol::channel::v1::ChannelId*>(&::bgs::protocol::channel::v1::ChannelId::default_instance()); + subscriber_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance()); +} + +UpdateMemberStateNotification::UpdateMemberStateNotification(const UpdateMemberStateNotification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.UpdateMemberStateNotification) +} + +void UpdateMemberStateNotification::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + channel_id_ = NULL; + subscriber_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +UpdateMemberStateNotification::~UpdateMemberStateNotification() { + // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.UpdateMemberStateNotification) + SharedDtor(); +} + +void UpdateMemberStateNotification::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + delete channel_id_; + delete subscriber_; + } +} + +void UpdateMemberStateNotification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* UpdateMemberStateNotification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return UpdateMemberStateNotification_descriptor_; +} + +const UpdateMemberStateNotification& UpdateMemberStateNotification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto(); + return *default_instance_; +} + +UpdateMemberStateNotification* UpdateMemberStateNotification::default_instance_ = NULL; + +UpdateMemberStateNotification* UpdateMemberStateNotification::New() const { + return new UpdateMemberStateNotification; +} + +void UpdateMemberStateNotification::Clear() { + if (_has_bits_[0 / 32] & 25) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_channel_id()) { + if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear(); + } + if (has_subscriber()) { + if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear(); + } + } + state_change_.Clear(); + removed_role_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool UpdateMemberStateNotification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.UpdateMemberStateNotification) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_state_change; + break; + } + + // repeated .bgs.protocol.channel.v1.Member state_change = 2; + case 2: { + if (tag == 18) { + parse_state_change: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_state_change())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_state_change; + if (input->ExpectTag(26)) goto parse_removed_role; + break; + } + + // repeated uint32 removed_role = 3 [packed = true]; + case 3: { + if (tag == 26) { + parse_removed_role: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_removed_role()))); + } else if (tag == 24) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 26, input, this->mutable_removed_role()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_channel_id; + break; + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4; + case 4: { + if (tag == 34) { + parse_channel_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_channel_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_subscriber; + break; + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 5; + case 5: { + if (tag == 42) { + parse_subscriber: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_subscriber())); + } 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:bgs.protocol.channel.v1.UpdateMemberStateNotification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.UpdateMemberStateNotification) + return false; +#undef DO_ +} + +void UpdateMemberStateNotification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.UpdateMemberStateNotification) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // repeated .bgs.protocol.channel.v1.Member state_change = 2; + for (int i = 0; i < this->state_change_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->state_change(i), output); + } + + // repeated uint32 removed_role = 3 [packed = true]; + if (this->removed_role_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(3, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_removed_role_cached_byte_size_); + } + for (int i = 0; i < this->removed_role_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag( + this->removed_role(i), output); + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4; + if (has_channel_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->channel_id(), output); + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 5; + if (has_subscriber()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, this->subscriber(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.UpdateMemberStateNotification) +} + +::google::protobuf::uint8* UpdateMemberStateNotification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.UpdateMemberStateNotification) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // repeated .bgs.protocol.channel.v1.Member state_change = 2; + for (int i = 0; i < this->state_change_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->state_change(i), target); + } + + // repeated uint32 removed_role = 3 [packed = true]; + if (this->removed_role_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 3, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _removed_role_cached_byte_size_, target); + } + for (int i = 0; i < this->removed_role_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32NoTagToArray(this->removed_role(i), target); + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4; + if (has_channel_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->channel_id(), target); + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 5; + if (has_subscriber()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 5, this->subscriber(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.UpdateMemberStateNotification) + return target; +} + +int UpdateMemberStateNotification::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4; + if (has_channel_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->channel_id()); + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 5; + if (has_subscriber()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->subscriber()); + } + + } + // repeated .bgs.protocol.channel.v1.Member state_change = 2; + total_size += 1 * this->state_change_size(); + for (int i = 0; i < this->state_change_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->state_change(i)); + } + + // repeated uint32 removed_role = 3 [packed = true]; + { + int data_size = 0; + for (int i = 0; i < this->removed_role_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->removed_role(i)); + } + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _removed_role_cached_byte_size_ = data_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_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 UpdateMemberStateNotification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const UpdateMemberStateNotification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void UpdateMemberStateNotification::MergeFrom(const UpdateMemberStateNotification& from) { + GOOGLE_CHECK_NE(&from, this); + state_change_.MergeFrom(from.state_change_); + removed_role_.MergeFrom(from.removed_role_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_channel_id()) { + mutable_channel_id()->::bgs::protocol::channel::v1::ChannelId::MergeFrom(from.channel_id()); + } + if (from.has_subscriber()) { + mutable_subscriber()->::bgs::protocol::account::v1::Identity::MergeFrom(from.subscriber()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void UpdateMemberStateNotification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void UpdateMemberStateNotification::CopyFrom(const UpdateMemberStateNotification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool UpdateMemberStateNotification::IsInitialized() const { + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + if (!::google::protobuf::internal::AllAreInitialized(this->state_change())) return false; + if (has_channel_id()) { + if (!this->channel_id().IsInitialized()) return false; + } + if (has_subscriber()) { + if (!this->subscriber().IsInitialized()) return false; + } + return true; +} + +void UpdateMemberStateNotification::Swap(UpdateMemberStateNotification* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + state_change_.Swap(&other->state_change_); + removed_role_.Swap(&other->removed_role_); + std::swap(channel_id_, other->channel_id_); + std::swap(subscriber_, other->subscriber_); + 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 UpdateMemberStateNotification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = UpdateMemberStateNotification_descriptor_; + metadata.reflection = UpdateMemberStateNotification_reflection_; + return metadata; +} + + +// =================================================================== + +google::protobuf::ServiceDescriptor const* ChannelService::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ChannelService_descriptor_; +} + +void ChannelService::AddMember(::bgs::protocol::channel::v1::AddMemberRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelService.AddMember(bgs.protocol.channel.v1.AddMemberRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 1, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void ChannelService::RemoveMember(::bgs::protocol::channel::v1::RemoveMemberRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelService.RemoveMember(bgs.protocol.channel.v1.RemoveMemberRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 2, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void ChannelService::SendMessage(::bgs::protocol::channel::v1::SendMessageRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelService.SendMessage(bgs.protocol.channel.v1.SendMessageRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 3, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void ChannelService::UpdateChannelState(::bgs::protocol::channel::v1::UpdateChannelStateRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelService.UpdateChannelState(bgs.protocol.channel.v1.UpdateChannelStateRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 4, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void ChannelService::UpdateMemberState(::bgs::protocol::channel::v1::UpdateMemberStateRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelService.UpdateMemberState(bgs.protocol.channel.v1.UpdateMemberStateRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 5, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void ChannelService::Dissolve(::bgs::protocol::channel::v1::DissolveRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelService.Dissolve(bgs.protocol.channel.v1.DissolveRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 6, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void ChannelService::SetRoles(::bgs::protocol::channel::v1::SetRolesRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelService.SetRoles(bgs.protocol.channel.v1.SetRolesRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 7, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void ChannelService::UnsubscribeMember(::bgs::protocol::channel::v1::UnsubscribeMemberRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelService.UnsubscribeMember(bgs.protocol.channel.v1.UnsubscribeMemberRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 8, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void ChannelService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) { + switch(methodId) { + case 1: { + ::bgs::protocol::channel::v1::AddMemberRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelService.AddMember server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleAddMember(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.AddMember(bgs.protocol.channel.v1.AddMemberRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 1, token, &response); + else + SendResponse(service_hash_, 1, token, status); + break; + } + case 2: { + ::bgs::protocol::channel::v1::RemoveMemberRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelService.RemoveMember server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleRemoveMember(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.RemoveMember(bgs.protocol.channel.v1.RemoveMemberRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 2, token, &response); + else + SendResponse(service_hash_, 2, token, status); + break; + } + case 3: { + ::bgs::protocol::channel::v1::SendMessageRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelService.SendMessage server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleSendMessage(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.SendMessage(bgs.protocol.channel.v1.SendMessageRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 3, token, &response); + else + SendResponse(service_hash_, 3, token, status); + break; + } + case 4: { + ::bgs::protocol::channel::v1::UpdateChannelStateRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelService.UpdateChannelState server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleUpdateChannelState(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.UpdateChannelState(bgs.protocol.channel.v1.UpdateChannelStateRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 4, token, &response); + else + SendResponse(service_hash_, 4, token, status); + break; + } + case 5: { + ::bgs::protocol::channel::v1::UpdateMemberStateRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelService.UpdateMemberState server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 5, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleUpdateMemberState(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.UpdateMemberState(bgs.protocol.channel.v1.UpdateMemberStateRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 5, token, &response); + else + SendResponse(service_hash_, 5, token, status); + break; + } + case 6: { + ::bgs::protocol::channel::v1::DissolveRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelService.Dissolve server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 6, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleDissolve(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.Dissolve(bgs.protocol.channel.v1.DissolveRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 6, token, &response); + else + SendResponse(service_hash_, 6, token, status); + break; + } + case 7: { + ::bgs::protocol::channel::v1::SetRolesRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelService.SetRoles server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 7, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleSetRoles(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.SetRoles(bgs.protocol.channel.v1.SetRolesRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 7, token, &response); + else + SendResponse(service_hash_, 7, token, status); + break; + } + case 8: { + ::bgs::protocol::channel::v1::UnsubscribeMemberRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelService.UnsubscribeMember server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 8, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleUnsubscribeMember(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.UnsubscribeMember(bgs.protocol.channel.v1.UnsubscribeMemberRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 8, token, &response); + else + SendResponse(service_hash_, 8, token, status); + break; + } + default: + TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId); + SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD); + break; + } +} + +uint32 ChannelService::HandleAddMember(::bgs::protocol::channel::v1::AddMemberRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelService.AddMember({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ChannelService::HandleRemoveMember(::bgs::protocol::channel::v1::RemoveMemberRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelService.RemoveMember({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ChannelService::HandleSendMessage(::bgs::protocol::channel::v1::SendMessageRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelService.SendMessage({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ChannelService::HandleUpdateChannelState(::bgs::protocol::channel::v1::UpdateChannelStateRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelService.UpdateChannelState({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ChannelService::HandleUpdateMemberState(::bgs::protocol::channel::v1::UpdateMemberStateRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelService.UpdateMemberState({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ChannelService::HandleDissolve(::bgs::protocol::channel::v1::DissolveRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelService.Dissolve({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ChannelService::HandleSetRoles(::bgs::protocol::channel::v1::SetRolesRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelService.SetRoles({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ChannelService::HandleUnsubscribeMember(::bgs::protocol::channel::v1::UnsubscribeMemberRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelService.UnsubscribeMember({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +// =================================================================== + +google::protobuf::ServiceDescriptor const* ChannelListener::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ChannelListener_descriptor_; +} + +void ChannelListener::OnJoin(::bgs::protocol::channel::v1::JoinNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelListener.OnJoin(bgs.protocol.channel.v1.JoinNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 1, request); +} + +void ChannelListener::OnMemberAdded(::bgs::protocol::channel::v1::MemberAddedNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelListener.OnMemberAdded(bgs.protocol.channel.v1.MemberAddedNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 2, request); +} + +void ChannelListener::OnLeave(::bgs::protocol::channel::v1::LeaveNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelListener.OnLeave(bgs.protocol.channel.v1.LeaveNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 3, request); +} + +void ChannelListener::OnMemberRemoved(::bgs::protocol::channel::v1::MemberRemovedNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelListener.OnMemberRemoved(bgs.protocol.channel.v1.MemberRemovedNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 4, request); +} + +void ChannelListener::OnSendMessage(::bgs::protocol::channel::v1::SendMessageNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelListener.OnSendMessage(bgs.protocol.channel.v1.SendMessageNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 5, request); +} + +void ChannelListener::OnUpdateChannelState(::bgs::protocol::channel::v1::UpdateChannelStateNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelListener.OnUpdateChannelState(bgs.protocol.channel.v1.UpdateChannelStateNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 6, request); +} + +void ChannelListener::OnUpdateMemberState(::bgs::protocol::channel::v1::UpdateMemberStateNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelListener.OnUpdateMemberState(bgs.protocol.channel.v1.UpdateMemberStateNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 7, request); +} + +void ChannelListener::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) { + switch(methodId) { + case 1: { + ::bgs::protocol::channel::v1::JoinNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelListener.OnJoin server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnJoin(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelListener.OnJoin(bgs.protocol.channel.v1.JoinNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 1, token, status); + break; + } + case 2: { + ::bgs::protocol::channel::v1::MemberAddedNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelListener.OnMemberAdded server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnMemberAdded(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelListener.OnMemberAdded(bgs.protocol.channel.v1.MemberAddedNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 2, token, status); + break; + } + case 3: { + ::bgs::protocol::channel::v1::LeaveNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelListener.OnLeave server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnLeave(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelListener.OnLeave(bgs.protocol.channel.v1.LeaveNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 3, token, status); + break; + } + case 4: { + ::bgs::protocol::channel::v1::MemberRemovedNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelListener.OnMemberRemoved server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnMemberRemoved(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelListener.OnMemberRemoved(bgs.protocol.channel.v1.MemberRemovedNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 4, token, status); + break; + } + case 5: { + ::bgs::protocol::channel::v1::SendMessageNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelListener.OnSendMessage server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 5, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnSendMessage(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelListener.OnSendMessage(bgs.protocol.channel.v1.SendMessageNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 5, token, status); + break; + } + case 6: { + ::bgs::protocol::channel::v1::UpdateChannelStateNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelListener.OnUpdateChannelState server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 6, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnUpdateChannelState(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelListener.OnUpdateChannelState(bgs.protocol.channel.v1.UpdateChannelStateNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 6, token, status); + break; + } + case 7: { + ::bgs::protocol::channel::v1::UpdateMemberStateNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelListener.OnUpdateMemberState server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 7, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnUpdateMemberState(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelListener.OnUpdateMemberState(bgs.protocol.channel.v1.UpdateMemberStateNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 7, token, status); + break; + } + default: + TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId); + SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD); + break; + } +} + +uint32 ChannelListener::HandleOnJoin(::bgs::protocol::channel::v1::JoinNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelListener.OnJoin({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ChannelListener::HandleOnMemberAdded(::bgs::protocol::channel::v1::MemberAddedNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelListener.OnMemberAdded({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ChannelListener::HandleOnLeave(::bgs::protocol::channel::v1::LeaveNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelListener.OnLeave({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ChannelListener::HandleOnMemberRemoved(::bgs::protocol::channel::v1::MemberRemovedNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelListener.OnMemberRemoved({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ChannelListener::HandleOnSendMessage(::bgs::protocol::channel::v1::SendMessageNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelListener.OnSendMessage({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ChannelListener::HandleOnUpdateChannelState(::bgs::protocol::channel::v1::UpdateChannelStateNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelListener.OnUpdateChannelState({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ChannelListener::HandleOnUpdateMemberState(::bgs::protocol::channel::v1::UpdateMemberStateNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelListener.OnUpdateMemberState({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace channel +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/channel_service.pb.h b/src/server/proto/Client/channel_service.pb.h new file mode 100644 index 00000000000..9f7ed094e63 --- /dev/null +++ b/src/server/proto/Client/channel_service.pb.h @@ -0,0 +1,4053 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: channel_service.proto + +#ifndef PROTOBUF_channel_5fservice_2eproto__INCLUDED +#define PROTOBUF_channel_5fservice_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include "account_types.pb.h" +#include "entity_types.pb.h" +#include "channel_types.pb.h" +#include "rpc_types.pb.h" +#include "ServiceBase.h" +#include "MessageBuffer.h" +#include +#include +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { +namespace channel { +namespace v1 { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto(); +void protobuf_AssignDesc_channel_5fservice_2eproto(); +void protobuf_ShutdownFile_channel_5fservice_2eproto(); + +class AddMemberRequest; +class RemoveMemberRequest; +class UnsubscribeMemberRequest; +class SendMessageRequest; +class UpdateChannelStateRequest; +class UpdateMemberStateRequest; +class DissolveRequest; +class SetRolesRequest; +class JoinNotification; +class MemberAddedNotification; +class LeaveNotification; +class MemberRemovedNotification; +class SendMessageNotification; +class UpdateChannelStateNotification; +class UpdateMemberStateNotification; + +// =================================================================== + +class TC_SHARED_API AddMemberRequest : public ::google::protobuf::Message { + public: + AddMemberRequest(); + virtual ~AddMemberRequest(); + + AddMemberRequest(const AddMemberRequest& from); + + inline AddMemberRequest& operator=(const AddMemberRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AddMemberRequest& default_instance(); + + void Swap(AddMemberRequest* other); + + // implements Message ---------------------------------------------- + + AddMemberRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AddMemberRequest& from); + void MergeFrom(const AddMemberRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // required .bgs.protocol.Identity member_identity = 2; + inline bool has_member_identity() const; + inline void clear_member_identity(); + static const int kMemberIdentityFieldNumber = 2; + inline const ::bgs::protocol::Identity& member_identity() const; + inline ::bgs::protocol::Identity* mutable_member_identity(); + inline ::bgs::protocol::Identity* release_member_identity(); + inline void set_allocated_member_identity(::bgs::protocol::Identity* member_identity); + + // required .bgs.protocol.channel.v1.MemberState member_state = 3; + inline bool has_member_state() const; + inline void clear_member_state(); + static const int kMemberStateFieldNumber = 3; + inline const ::bgs::protocol::channel::v1::MemberState& member_state() const; + inline ::bgs::protocol::channel::v1::MemberState* mutable_member_state(); + inline ::bgs::protocol::channel::v1::MemberState* release_member_state(); + inline void set_allocated_member_state(::bgs::protocol::channel::v1::MemberState* member_state); + + // required uint64 object_id = 4; + inline bool has_object_id() const; + inline void clear_object_id(); + static const int kObjectIdFieldNumber = 4; + inline ::google::protobuf::uint64 object_id() const; + inline void set_object_id(::google::protobuf::uint64 value); + + // optional bool subscribe = 5 [default = true]; + inline bool has_subscribe() const; + inline void clear_subscribe(); + static const int kSubscribeFieldNumber = 5; + inline bool subscribe() const; + inline void set_subscribe(bool value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.AddMemberRequest) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_member_identity(); + inline void clear_has_member_identity(); + inline void set_has_member_state(); + inline void clear_has_member_state(); + inline void set_has_object_id(); + inline void clear_has_object_id(); + inline void set_has_subscribe(); + inline void clear_has_subscribe(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::bgs::protocol::Identity* member_identity_; + ::bgs::protocol::channel::v1::MemberState* member_state_; + ::google::protobuf::uint64 object_id_; + bool subscribe_; + friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto(); + friend void protobuf_AssignDesc_channel_5fservice_2eproto(); + friend void protobuf_ShutdownFile_channel_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static AddMemberRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API RemoveMemberRequest : public ::google::protobuf::Message { + public: + RemoveMemberRequest(); + virtual ~RemoveMemberRequest(); + + RemoveMemberRequest(const RemoveMemberRequest& from); + + inline RemoveMemberRequest& operator=(const RemoveMemberRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const RemoveMemberRequest& default_instance(); + + void Swap(RemoveMemberRequest* other); + + // implements Message ---------------------------------------------- + + RemoveMemberRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const RemoveMemberRequest& from); + void MergeFrom(const RemoveMemberRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // required .bgs.protocol.EntityId member_id = 2; + inline bool has_member_id() const; + inline void clear_member_id(); + static const int kMemberIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& member_id() const; + inline ::bgs::protocol::EntityId* mutable_member_id(); + inline ::bgs::protocol::EntityId* release_member_id(); + inline void set_allocated_member_id(::bgs::protocol::EntityId* member_id); + + // optional uint32 reason = 3; + inline bool has_reason() const; + inline void clear_reason(); + static const int kReasonFieldNumber = 3; + inline ::google::protobuf::uint32 reason() const; + inline void set_reason(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.RemoveMemberRequest) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_member_id(); + inline void clear_has_member_id(); + inline void set_has_reason(); + inline void clear_has_reason(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::bgs::protocol::EntityId* member_id_; + ::google::protobuf::uint32 reason_; + friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto(); + friend void protobuf_AssignDesc_channel_5fservice_2eproto(); + friend void protobuf_ShutdownFile_channel_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static RemoveMemberRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API UnsubscribeMemberRequest : public ::google::protobuf::Message { + public: + UnsubscribeMemberRequest(); + virtual ~UnsubscribeMemberRequest(); + + UnsubscribeMemberRequest(const UnsubscribeMemberRequest& from); + + inline UnsubscribeMemberRequest& operator=(const UnsubscribeMemberRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const UnsubscribeMemberRequest& default_instance(); + + void Swap(UnsubscribeMemberRequest* other); + + // implements Message ---------------------------------------------- + + UnsubscribeMemberRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const UnsubscribeMemberRequest& from); + void MergeFrom(const UnsubscribeMemberRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // required .bgs.protocol.EntityId member_id = 2; + inline bool has_member_id() const; + inline void clear_member_id(); + static const int kMemberIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& member_id() const; + inline ::bgs::protocol::EntityId* mutable_member_id(); + inline ::bgs::protocol::EntityId* release_member_id(); + inline void set_allocated_member_id(::bgs::protocol::EntityId* member_id); + + // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.UnsubscribeMemberRequest) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_member_id(); + inline void clear_has_member_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::bgs::protocol::EntityId* member_id_; + friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto(); + friend void protobuf_AssignDesc_channel_5fservice_2eproto(); + friend void protobuf_ShutdownFile_channel_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static UnsubscribeMemberRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API SendMessageRequest : public ::google::protobuf::Message { + public: + SendMessageRequest(); + virtual ~SendMessageRequest(); + + SendMessageRequest(const SendMessageRequest& from); + + inline SendMessageRequest& operator=(const SendMessageRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SendMessageRequest& default_instance(); + + void Swap(SendMessageRequest* other); + + // implements Message ---------------------------------------------- + + SendMessageRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SendMessageRequest& from); + void MergeFrom(const SendMessageRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // required .bgs.protocol.channel.v1.Message message = 2; + inline bool has_message() const; + inline void clear_message(); + static const int kMessageFieldNumber = 2; + inline const ::bgs::protocol::channel::v1::Message& message() const; + inline ::bgs::protocol::channel::v1::Message* mutable_message(); + inline ::bgs::protocol::channel::v1::Message* release_message(); + inline void set_allocated_message(::bgs::protocol::channel::v1::Message* message); + + // optional uint64 required_privileges = 3 [default = 0]; + inline bool has_required_privileges() const; + inline void clear_required_privileges(); + static const int kRequiredPrivilegesFieldNumber = 3; + inline ::google::protobuf::uint64 required_privileges() const; + inline void set_required_privileges(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.SendMessageRequest) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_message(); + inline void clear_has_message(); + inline void set_has_required_privileges(); + inline void clear_has_required_privileges(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::bgs::protocol::channel::v1::Message* message_; + ::google::protobuf::uint64 required_privileges_; + friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto(); + friend void protobuf_AssignDesc_channel_5fservice_2eproto(); + friend void protobuf_ShutdownFile_channel_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static SendMessageRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API UpdateChannelStateRequest : public ::google::protobuf::Message { + public: + UpdateChannelStateRequest(); + virtual ~UpdateChannelStateRequest(); + + UpdateChannelStateRequest(const UpdateChannelStateRequest& from); + + inline UpdateChannelStateRequest& operator=(const UpdateChannelStateRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const UpdateChannelStateRequest& default_instance(); + + void Swap(UpdateChannelStateRequest* other); + + // implements Message ---------------------------------------------- + + UpdateChannelStateRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const UpdateChannelStateRequest& from); + void MergeFrom(const UpdateChannelStateRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // required .bgs.protocol.channel.v1.ChannelState state_change = 2; + inline bool has_state_change() const; + inline void clear_state_change(); + static const int kStateChangeFieldNumber = 2; + inline const ::bgs::protocol::channel::v1::ChannelState& state_change() const; + inline ::bgs::protocol::channel::v1::ChannelState* mutable_state_change(); + inline ::bgs::protocol::channel::v1::ChannelState* release_state_change(); + inline void set_allocated_state_change(::bgs::protocol::channel::v1::ChannelState* state_change); + + // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.UpdateChannelStateRequest) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_state_change(); + inline void clear_has_state_change(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::bgs::protocol::channel::v1::ChannelState* state_change_; + friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto(); + friend void protobuf_AssignDesc_channel_5fservice_2eproto(); + friend void protobuf_ShutdownFile_channel_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static UpdateChannelStateRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API UpdateMemberStateRequest : public ::google::protobuf::Message { + public: + UpdateMemberStateRequest(); + virtual ~UpdateMemberStateRequest(); + + UpdateMemberStateRequest(const UpdateMemberStateRequest& from); + + inline UpdateMemberStateRequest& operator=(const UpdateMemberStateRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const UpdateMemberStateRequest& default_instance(); + + void Swap(UpdateMemberStateRequest* other); + + // implements Message ---------------------------------------------- + + UpdateMemberStateRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const UpdateMemberStateRequest& from); + void MergeFrom(const UpdateMemberStateRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // repeated .bgs.protocol.channel.v1.Member state_change = 2; + inline int state_change_size() const; + inline void clear_state_change(); + static const int kStateChangeFieldNumber = 2; + inline const ::bgs::protocol::channel::v1::Member& state_change(int index) const; + inline ::bgs::protocol::channel::v1::Member* mutable_state_change(int index); + inline ::bgs::protocol::channel::v1::Member* add_state_change(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >& + state_change() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >* + mutable_state_change(); + + // repeated uint32 removed_role = 3 [packed = true]; + inline int removed_role_size() const; + inline void clear_removed_role(); + static const int kRemovedRoleFieldNumber = 3; + inline ::google::protobuf::uint32 removed_role(int index) const; + inline void set_removed_role(int index, ::google::protobuf::uint32 value); + inline void add_removed_role(::google::protobuf::uint32 value); + inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + removed_role() const; + inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_removed_role(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.UpdateMemberStateRequest) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member > state_change_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > removed_role_; + mutable int _removed_role_cached_byte_size_; + friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto(); + friend void protobuf_AssignDesc_channel_5fservice_2eproto(); + friend void protobuf_ShutdownFile_channel_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static UpdateMemberStateRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API DissolveRequest : public ::google::protobuf::Message { + public: + DissolveRequest(); + virtual ~DissolveRequest(); + + DissolveRequest(const DissolveRequest& from); + + inline DissolveRequest& operator=(const DissolveRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const DissolveRequest& default_instance(); + + void Swap(DissolveRequest* other); + + // implements Message ---------------------------------------------- + + DissolveRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const DissolveRequest& from); + void MergeFrom(const DissolveRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // optional uint32 reason = 2; + inline bool has_reason() const; + inline void clear_reason(); + static const int kReasonFieldNumber = 2; + inline ::google::protobuf::uint32 reason() const; + inline void set_reason(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.DissolveRequest) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_reason(); + inline void clear_has_reason(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::google::protobuf::uint32 reason_; + friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto(); + friend void protobuf_AssignDesc_channel_5fservice_2eproto(); + friend void protobuf_ShutdownFile_channel_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static DissolveRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API SetRolesRequest : public ::google::protobuf::Message { + public: + SetRolesRequest(); + virtual ~SetRolesRequest(); + + SetRolesRequest(const SetRolesRequest& from); + + inline SetRolesRequest& operator=(const SetRolesRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SetRolesRequest& default_instance(); + + void Swap(SetRolesRequest* other); + + // implements Message ---------------------------------------------- + + SetRolesRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SetRolesRequest& from); + void MergeFrom(const SetRolesRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // repeated uint32 role = 2 [packed = true]; + inline int role_size() const; + inline void clear_role(); + static const int kRoleFieldNumber = 2; + inline ::google::protobuf::uint32 role(int index) const; + inline void set_role(int index, ::google::protobuf::uint32 value); + inline void add_role(::google::protobuf::uint32 value); + inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + role() const; + inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_role(); + + // repeated .bgs.protocol.EntityId member_id = 3; + inline int member_id_size() const; + inline void clear_member_id(); + static const int kMemberIdFieldNumber = 3; + inline const ::bgs::protocol::EntityId& member_id(int index) const; + inline ::bgs::protocol::EntityId* mutable_member_id(int index); + inline ::bgs::protocol::EntityId* add_member_id(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId >& + member_id() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId >* + mutable_member_id(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.SetRolesRequest) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > role_; + mutable int _role_cached_byte_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId > member_id_; + friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto(); + friend void protobuf_AssignDesc_channel_5fservice_2eproto(); + friend void protobuf_ShutdownFile_channel_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static SetRolesRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API JoinNotification : public ::google::protobuf::Message { + public: + JoinNotification(); + virtual ~JoinNotification(); + + JoinNotification(const JoinNotification& from); + + inline JoinNotification& operator=(const JoinNotification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const JoinNotification& default_instance(); + + void Swap(JoinNotification* other); + + // implements Message ---------------------------------------------- + + JoinNotification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const JoinNotification& from); + void MergeFrom(const JoinNotification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.channel.v1.Member self = 1; + inline bool has_self() const; + inline void clear_self(); + static const int kSelfFieldNumber = 1; + inline const ::bgs::protocol::channel::v1::Member& self() const; + inline ::bgs::protocol::channel::v1::Member* mutable_self(); + inline ::bgs::protocol::channel::v1::Member* release_self(); + inline void set_allocated_self(::bgs::protocol::channel::v1::Member* self); + + // repeated .bgs.protocol.channel.v1.Member member = 2; + inline int member_size() const; + inline void clear_member(); + static const int kMemberFieldNumber = 2; + inline const ::bgs::protocol::channel::v1::Member& member(int index) const; + inline ::bgs::protocol::channel::v1::Member* mutable_member(int index); + inline ::bgs::protocol::channel::v1::Member* add_member(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >& + member() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >* + mutable_member(); + + // required .bgs.protocol.channel.v1.ChannelState channel_state = 3; + inline bool has_channel_state() const; + inline void clear_channel_state(); + static const int kChannelStateFieldNumber = 3; + inline const ::bgs::protocol::channel::v1::ChannelState& channel_state() const; + inline ::bgs::protocol::channel::v1::ChannelState* mutable_channel_state(); + inline ::bgs::protocol::channel::v1::ChannelState* release_channel_state(); + inline void set_allocated_channel_state(::bgs::protocol::channel::v1::ChannelState* channel_state); + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4; + inline bool has_channel_id() const; + inline void clear_channel_id(); + static const int kChannelIdFieldNumber = 4; + inline const ::bgs::protocol::channel::v1::ChannelId& channel_id() const; + inline ::bgs::protocol::channel::v1::ChannelId* mutable_channel_id(); + inline ::bgs::protocol::channel::v1::ChannelId* release_channel_id(); + inline void set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id); + + // optional .bgs.protocol.account.v1.Identity subscriber = 5; + inline bool has_subscriber() const; + inline void clear_subscriber(); + static const int kSubscriberFieldNumber = 5; + inline const ::bgs::protocol::account::v1::Identity& subscriber() const; + inline ::bgs::protocol::account::v1::Identity* mutable_subscriber(); + inline ::bgs::protocol::account::v1::Identity* release_subscriber(); + inline void set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber); + + // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.JoinNotification) + private: + inline void set_has_self(); + inline void clear_has_self(); + inline void set_has_channel_state(); + inline void clear_has_channel_state(); + inline void set_has_channel_id(); + inline void clear_has_channel_id(); + inline void set_has_subscriber(); + inline void clear_has_subscriber(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::channel::v1::Member* self_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member > member_; + ::bgs::protocol::channel::v1::ChannelState* channel_state_; + ::bgs::protocol::channel::v1::ChannelId* channel_id_; + ::bgs::protocol::account::v1::Identity* subscriber_; + friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto(); + friend void protobuf_AssignDesc_channel_5fservice_2eproto(); + friend void protobuf_ShutdownFile_channel_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static JoinNotification* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API MemberAddedNotification : public ::google::protobuf::Message { + public: + MemberAddedNotification(); + virtual ~MemberAddedNotification(); + + MemberAddedNotification(const MemberAddedNotification& from); + + inline MemberAddedNotification& operator=(const MemberAddedNotification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const MemberAddedNotification& default_instance(); + + void Swap(MemberAddedNotification* other); + + // implements Message ---------------------------------------------- + + MemberAddedNotification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const MemberAddedNotification& from); + void MergeFrom(const MemberAddedNotification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.channel.v1.Member member = 1; + inline bool has_member() const; + inline void clear_member(); + static const int kMemberFieldNumber = 1; + inline const ::bgs::protocol::channel::v1::Member& member() const; + inline ::bgs::protocol::channel::v1::Member* mutable_member(); + inline ::bgs::protocol::channel::v1::Member* release_member(); + inline void set_allocated_member(::bgs::protocol::channel::v1::Member* member); + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 2; + inline bool has_channel_id() const; + inline void clear_channel_id(); + static const int kChannelIdFieldNumber = 2; + inline const ::bgs::protocol::channel::v1::ChannelId& channel_id() const; + inline ::bgs::protocol::channel::v1::ChannelId* mutable_channel_id(); + inline ::bgs::protocol::channel::v1::ChannelId* release_channel_id(); + inline void set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id); + + // optional .bgs.protocol.account.v1.Identity subscriber = 3; + inline bool has_subscriber() const; + inline void clear_subscriber(); + static const int kSubscriberFieldNumber = 3; + inline const ::bgs::protocol::account::v1::Identity& subscriber() const; + inline ::bgs::protocol::account::v1::Identity* mutable_subscriber(); + inline ::bgs::protocol::account::v1::Identity* release_subscriber(); + inline void set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber); + + // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.MemberAddedNotification) + private: + inline void set_has_member(); + inline void clear_has_member(); + inline void set_has_channel_id(); + inline void clear_has_channel_id(); + inline void set_has_subscriber(); + inline void clear_has_subscriber(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::channel::v1::Member* member_; + ::bgs::protocol::channel::v1::ChannelId* channel_id_; + ::bgs::protocol::account::v1::Identity* subscriber_; + friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto(); + friend void protobuf_AssignDesc_channel_5fservice_2eproto(); + friend void protobuf_ShutdownFile_channel_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static MemberAddedNotification* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API LeaveNotification : public ::google::protobuf::Message { + public: + LeaveNotification(); + virtual ~LeaveNotification(); + + LeaveNotification(const LeaveNotification& from); + + inline LeaveNotification& operator=(const LeaveNotification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const LeaveNotification& default_instance(); + + void Swap(LeaveNotification* other); + + // implements Message ---------------------------------------------- + + LeaveNotification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const LeaveNotification& from); + void MergeFrom(const LeaveNotification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // required .bgs.protocol.EntityId member_id = 2; + inline bool has_member_id() const; + inline void clear_member_id(); + static const int kMemberIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& member_id() const; + inline ::bgs::protocol::EntityId* mutable_member_id(); + inline ::bgs::protocol::EntityId* release_member_id(); + inline void set_allocated_member_id(::bgs::protocol::EntityId* member_id); + + // optional uint32 reason = 3; + inline bool has_reason() const; + inline void clear_reason(); + static const int kReasonFieldNumber = 3; + inline ::google::protobuf::uint32 reason() const; + inline void set_reason(::google::protobuf::uint32 value); + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4; + inline bool has_channel_id() const; + inline void clear_channel_id(); + static const int kChannelIdFieldNumber = 4; + inline const ::bgs::protocol::channel::v1::ChannelId& channel_id() const; + inline ::bgs::protocol::channel::v1::ChannelId* mutable_channel_id(); + inline ::bgs::protocol::channel::v1::ChannelId* release_channel_id(); + inline void set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id); + + // optional .bgs.protocol.account.v1.Identity subscriber = 5; + inline bool has_subscriber() const; + inline void clear_subscriber(); + static const int kSubscriberFieldNumber = 5; + inline const ::bgs::protocol::account::v1::Identity& subscriber() const; + inline ::bgs::protocol::account::v1::Identity* mutable_subscriber(); + inline ::bgs::protocol::account::v1::Identity* release_subscriber(); + inline void set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber); + + // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.LeaveNotification) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_member_id(); + inline void clear_has_member_id(); + inline void set_has_reason(); + inline void clear_has_reason(); + inline void set_has_channel_id(); + inline void clear_has_channel_id(); + inline void set_has_subscriber(); + inline void clear_has_subscriber(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::bgs::protocol::EntityId* member_id_; + ::bgs::protocol::channel::v1::ChannelId* channel_id_; + ::bgs::protocol::account::v1::Identity* subscriber_; + ::google::protobuf::uint32 reason_; + friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto(); + friend void protobuf_AssignDesc_channel_5fservice_2eproto(); + friend void protobuf_ShutdownFile_channel_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static LeaveNotification* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API MemberRemovedNotification : public ::google::protobuf::Message { + public: + MemberRemovedNotification(); + virtual ~MemberRemovedNotification(); + + MemberRemovedNotification(const MemberRemovedNotification& from); + + inline MemberRemovedNotification& operator=(const MemberRemovedNotification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const MemberRemovedNotification& default_instance(); + + void Swap(MemberRemovedNotification* other); + + // implements Message ---------------------------------------------- + + MemberRemovedNotification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const MemberRemovedNotification& from); + void MergeFrom(const MemberRemovedNotification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // required .bgs.protocol.EntityId member_id = 2; + inline bool has_member_id() const; + inline void clear_member_id(); + static const int kMemberIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& member_id() const; + inline ::bgs::protocol::EntityId* mutable_member_id(); + inline ::bgs::protocol::EntityId* release_member_id(); + inline void set_allocated_member_id(::bgs::protocol::EntityId* member_id); + + // optional uint32 reason = 3; + inline bool has_reason() const; + inline void clear_reason(); + static const int kReasonFieldNumber = 3; + inline ::google::protobuf::uint32 reason() const; + inline void set_reason(::google::protobuf::uint32 value); + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4; + inline bool has_channel_id() const; + inline void clear_channel_id(); + static const int kChannelIdFieldNumber = 4; + inline const ::bgs::protocol::channel::v1::ChannelId& channel_id() const; + inline ::bgs::protocol::channel::v1::ChannelId* mutable_channel_id(); + inline ::bgs::protocol::channel::v1::ChannelId* release_channel_id(); + inline void set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id); + + // optional .bgs.protocol.account.v1.Identity subscriber = 5; + inline bool has_subscriber() const; + inline void clear_subscriber(); + static const int kSubscriberFieldNumber = 5; + inline const ::bgs::protocol::account::v1::Identity& subscriber() const; + inline ::bgs::protocol::account::v1::Identity* mutable_subscriber(); + inline ::bgs::protocol::account::v1::Identity* release_subscriber(); + inline void set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber); + + // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.MemberRemovedNotification) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_member_id(); + inline void clear_has_member_id(); + inline void set_has_reason(); + inline void clear_has_reason(); + inline void set_has_channel_id(); + inline void clear_has_channel_id(); + inline void set_has_subscriber(); + inline void clear_has_subscriber(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::bgs::protocol::EntityId* member_id_; + ::bgs::protocol::channel::v1::ChannelId* channel_id_; + ::bgs::protocol::account::v1::Identity* subscriber_; + ::google::protobuf::uint32 reason_; + friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto(); + friend void protobuf_AssignDesc_channel_5fservice_2eproto(); + friend void protobuf_ShutdownFile_channel_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static MemberRemovedNotification* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API SendMessageNotification : public ::google::protobuf::Message { + public: + SendMessageNotification(); + virtual ~SendMessageNotification(); + + SendMessageNotification(const SendMessageNotification& from); + + inline SendMessageNotification& operator=(const SendMessageNotification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SendMessageNotification& default_instance(); + + void Swap(SendMessageNotification* other); + + // implements Message ---------------------------------------------- + + SendMessageNotification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SendMessageNotification& from); + void MergeFrom(const SendMessageNotification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // required .bgs.protocol.channel.v1.Message message = 2; + inline bool has_message() const; + inline void clear_message(); + static const int kMessageFieldNumber = 2; + inline const ::bgs::protocol::channel::v1::Message& message() const; + inline ::bgs::protocol::channel::v1::Message* mutable_message(); + inline ::bgs::protocol::channel::v1::Message* release_message(); + inline void set_allocated_message(::bgs::protocol::channel::v1::Message* message); + + // optional uint64 required_privileges = 3 [default = 0]; + inline bool has_required_privileges() const; + inline void clear_required_privileges(); + static const int kRequiredPrivilegesFieldNumber = 3; + inline ::google::protobuf::uint64 required_privileges() const; + inline void set_required_privileges(::google::protobuf::uint64 value); + + // optional string identity = 4; + inline bool has_identity() const; + inline void clear_identity(); + static const int kIdentityFieldNumber = 4; + inline const ::std::string& identity() const; + inline void set_identity(const ::std::string& value); + inline void set_identity(const char* value); + inline void set_identity(const char* value, size_t size); + inline ::std::string* mutable_identity(); + inline ::std::string* release_identity(); + inline void set_allocated_identity(::std::string* identity); + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 5; + inline bool has_channel_id() const; + inline void clear_channel_id(); + static const int kChannelIdFieldNumber = 5; + inline const ::bgs::protocol::channel::v1::ChannelId& channel_id() const; + inline ::bgs::protocol::channel::v1::ChannelId* mutable_channel_id(); + inline ::bgs::protocol::channel::v1::ChannelId* release_channel_id(); + inline void set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id); + + // optional .bgs.protocol.account.v1.Identity subscriber = 6; + inline bool has_subscriber() const; + inline void clear_subscriber(); + static const int kSubscriberFieldNumber = 6; + inline const ::bgs::protocol::account::v1::Identity& subscriber() const; + inline ::bgs::protocol::account::v1::Identity* mutable_subscriber(); + inline ::bgs::protocol::account::v1::Identity* release_subscriber(); + inline void set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber); + + // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.SendMessageNotification) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_message(); + inline void clear_has_message(); + inline void set_has_required_privileges(); + inline void clear_has_required_privileges(); + inline void set_has_identity(); + inline void clear_has_identity(); + inline void set_has_channel_id(); + inline void clear_has_channel_id(); + inline void set_has_subscriber(); + inline void clear_has_subscriber(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::bgs::protocol::channel::v1::Message* message_; + ::google::protobuf::uint64 required_privileges_; + ::std::string* identity_; + ::bgs::protocol::channel::v1::ChannelId* channel_id_; + ::bgs::protocol::account::v1::Identity* subscriber_; + friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto(); + friend void protobuf_AssignDesc_channel_5fservice_2eproto(); + friend void protobuf_ShutdownFile_channel_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static SendMessageNotification* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API UpdateChannelStateNotification : public ::google::protobuf::Message { + public: + UpdateChannelStateNotification(); + virtual ~UpdateChannelStateNotification(); + + UpdateChannelStateNotification(const UpdateChannelStateNotification& from); + + inline UpdateChannelStateNotification& operator=(const UpdateChannelStateNotification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const UpdateChannelStateNotification& default_instance(); + + void Swap(UpdateChannelStateNotification* other); + + // implements Message ---------------------------------------------- + + UpdateChannelStateNotification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const UpdateChannelStateNotification& from); + void MergeFrom(const UpdateChannelStateNotification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // required .bgs.protocol.channel.v1.ChannelState state_change = 2; + inline bool has_state_change() const; + inline void clear_state_change(); + static const int kStateChangeFieldNumber = 2; + inline const ::bgs::protocol::channel::v1::ChannelState& state_change() const; + inline ::bgs::protocol::channel::v1::ChannelState* mutable_state_change(); + inline ::bgs::protocol::channel::v1::ChannelState* release_state_change(); + inline void set_allocated_state_change(::bgs::protocol::channel::v1::ChannelState* state_change); + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 3; + inline bool has_channel_id() const; + inline void clear_channel_id(); + static const int kChannelIdFieldNumber = 3; + inline const ::bgs::protocol::channel::v1::ChannelId& channel_id() const; + inline ::bgs::protocol::channel::v1::ChannelId* mutable_channel_id(); + inline ::bgs::protocol::channel::v1::ChannelId* release_channel_id(); + inline void set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id); + + // optional .bgs.protocol.account.v1.Identity subscriber = 4; + inline bool has_subscriber() const; + inline void clear_subscriber(); + static const int kSubscriberFieldNumber = 4; + inline const ::bgs::protocol::account::v1::Identity& subscriber() const; + inline ::bgs::protocol::account::v1::Identity* mutable_subscriber(); + inline ::bgs::protocol::account::v1::Identity* release_subscriber(); + inline void set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber); + + // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.UpdateChannelStateNotification) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_state_change(); + inline void clear_has_state_change(); + inline void set_has_channel_id(); + inline void clear_has_channel_id(); + inline void set_has_subscriber(); + inline void clear_has_subscriber(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::bgs::protocol::channel::v1::ChannelState* state_change_; + ::bgs::protocol::channel::v1::ChannelId* channel_id_; + ::bgs::protocol::account::v1::Identity* subscriber_; + friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto(); + friend void protobuf_AssignDesc_channel_5fservice_2eproto(); + friend void protobuf_ShutdownFile_channel_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static UpdateChannelStateNotification* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API UpdateMemberStateNotification : public ::google::protobuf::Message { + public: + UpdateMemberStateNotification(); + virtual ~UpdateMemberStateNotification(); + + UpdateMemberStateNotification(const UpdateMemberStateNotification& from); + + inline UpdateMemberStateNotification& operator=(const UpdateMemberStateNotification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const UpdateMemberStateNotification& default_instance(); + + void Swap(UpdateMemberStateNotification* other); + + // implements Message ---------------------------------------------- + + UpdateMemberStateNotification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const UpdateMemberStateNotification& from); + void MergeFrom(const UpdateMemberStateNotification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // repeated .bgs.protocol.channel.v1.Member state_change = 2; + inline int state_change_size() const; + inline void clear_state_change(); + static const int kStateChangeFieldNumber = 2; + inline const ::bgs::protocol::channel::v1::Member& state_change(int index) const; + inline ::bgs::protocol::channel::v1::Member* mutable_state_change(int index); + inline ::bgs::protocol::channel::v1::Member* add_state_change(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >& + state_change() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >* + mutable_state_change(); + + // repeated uint32 removed_role = 3 [packed = true]; + inline int removed_role_size() const; + inline void clear_removed_role(); + static const int kRemovedRoleFieldNumber = 3; + inline ::google::protobuf::uint32 removed_role(int index) const; + inline void set_removed_role(int index, ::google::protobuf::uint32 value); + inline void add_removed_role(::google::protobuf::uint32 value); + inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + removed_role() const; + inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_removed_role(); + + // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4; + inline bool has_channel_id() const; + inline void clear_channel_id(); + static const int kChannelIdFieldNumber = 4; + inline const ::bgs::protocol::channel::v1::ChannelId& channel_id() const; + inline ::bgs::protocol::channel::v1::ChannelId* mutable_channel_id(); + inline ::bgs::protocol::channel::v1::ChannelId* release_channel_id(); + inline void set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id); + + // optional .bgs.protocol.account.v1.Identity subscriber = 5; + inline bool has_subscriber() const; + inline void clear_subscriber(); + static const int kSubscriberFieldNumber = 5; + inline const ::bgs::protocol::account::v1::Identity& subscriber() const; + inline ::bgs::protocol::account::v1::Identity* mutable_subscriber(); + inline ::bgs::protocol::account::v1::Identity* release_subscriber(); + inline void set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber); + + // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.UpdateMemberStateNotification) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_channel_id(); + inline void clear_has_channel_id(); + inline void set_has_subscriber(); + inline void clear_has_subscriber(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member > state_change_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > removed_role_; + mutable int _removed_role_cached_byte_size_; + ::bgs::protocol::channel::v1::ChannelId* channel_id_; + ::bgs::protocol::account::v1::Identity* subscriber_; + friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto(); + friend void protobuf_AssignDesc_channel_5fservice_2eproto(); + friend void protobuf_ShutdownFile_channel_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static UpdateMemberStateNotification* default_instance_; +}; +// =================================================================== + +class TC_SHARED_API ChannelService : public ServiceBase +{ + public: + + template + explicit ChannelService(HashSelector) : service_hash_(HashSelector::Result::value) { } + + typedef std::integral_constant OriginalHash; + typedef std::integral_constant NameHash; + + static google::protobuf::ServiceDescriptor const* descriptor(); + + // client methods -------------------------------------------------- + + void AddMember(::bgs::protocol::channel::v1::AddMemberRequest const* request, std::function responseCallback); + void RemoveMember(::bgs::protocol::channel::v1::RemoveMemberRequest const* request, std::function responseCallback); + void SendMessage(::bgs::protocol::channel::v1::SendMessageRequest const* request, std::function responseCallback); + void UpdateChannelState(::bgs::protocol::channel::v1::UpdateChannelStateRequest const* request, std::function responseCallback); + void UpdateMemberState(::bgs::protocol::channel::v1::UpdateMemberStateRequest const* request, std::function responseCallback); + void Dissolve(::bgs::protocol::channel::v1::DissolveRequest const* request, std::function responseCallback); + void SetRoles(::bgs::protocol::channel::v1::SetRolesRequest const* request, std::function responseCallback); + void UnsubscribeMember(::bgs::protocol::channel::v1::UnsubscribeMemberRequest const* request, std::function responseCallback); + // server methods -------------------------------------------------- + + void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final; + + protected: + virtual uint32 HandleAddMember(::bgs::protocol::channel::v1::AddMemberRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleRemoveMember(::bgs::protocol::channel::v1::RemoveMemberRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleSendMessage(::bgs::protocol::channel::v1::SendMessageRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleUpdateChannelState(::bgs::protocol::channel::v1::UpdateChannelStateRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleUpdateMemberState(::bgs::protocol::channel::v1::UpdateMemberStateRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleDissolve(::bgs::protocol::channel::v1::DissolveRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleSetRoles(::bgs::protocol::channel::v1::SetRolesRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleUnsubscribeMember(::bgs::protocol::channel::v1::UnsubscribeMemberRequest const* request, ::bgs::protocol::NoData* response); + + private: + uint32 service_hash_; + + GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ChannelService); +}; + +// ------------------------------------------------------------------- + +class TC_SHARED_API ChannelListener : public ServiceBase +{ + public: + + template + explicit ChannelListener(HashSelector) : service_hash_(HashSelector::Result::value) { } + + typedef std::integral_constant OriginalHash; + typedef std::integral_constant NameHash; + + static google::protobuf::ServiceDescriptor const* descriptor(); + + // client methods -------------------------------------------------- + + void OnJoin(::bgs::protocol::channel::v1::JoinNotification const* request); + void OnMemberAdded(::bgs::protocol::channel::v1::MemberAddedNotification const* request); + void OnLeave(::bgs::protocol::channel::v1::LeaveNotification const* request); + void OnMemberRemoved(::bgs::protocol::channel::v1::MemberRemovedNotification const* request); + void OnSendMessage(::bgs::protocol::channel::v1::SendMessageNotification const* request); + void OnUpdateChannelState(::bgs::protocol::channel::v1::UpdateChannelStateNotification const* request); + void OnUpdateMemberState(::bgs::protocol::channel::v1::UpdateMemberStateNotification const* request); + // server methods -------------------------------------------------- + + void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final; + + protected: + virtual uint32 HandleOnJoin(::bgs::protocol::channel::v1::JoinNotification const* request); + virtual uint32 HandleOnMemberAdded(::bgs::protocol::channel::v1::MemberAddedNotification const* request); + virtual uint32 HandleOnLeave(::bgs::protocol::channel::v1::LeaveNotification const* request); + virtual uint32 HandleOnMemberRemoved(::bgs::protocol::channel::v1::MemberRemovedNotification const* request); + virtual uint32 HandleOnSendMessage(::bgs::protocol::channel::v1::SendMessageNotification const* request); + virtual uint32 HandleOnUpdateChannelState(::bgs::protocol::channel::v1::UpdateChannelStateNotification const* request); + virtual uint32 HandleOnUpdateMemberState(::bgs::protocol::channel::v1::UpdateMemberStateNotification const* request); + + private: + uint32 service_hash_; + + GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ChannelListener); +}; + +// =================================================================== + + +// =================================================================== + +// AddMemberRequest + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool AddMemberRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AddMemberRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void AddMemberRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AddMemberRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& AddMemberRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.AddMemberRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* AddMemberRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.AddMemberRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* AddMemberRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void AddMemberRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.AddMemberRequest.agent_id) +} + +// required .bgs.protocol.Identity member_identity = 2; +inline bool AddMemberRequest::has_member_identity() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void AddMemberRequest::set_has_member_identity() { + _has_bits_[0] |= 0x00000002u; +} +inline void AddMemberRequest::clear_has_member_identity() { + _has_bits_[0] &= ~0x00000002u; +} +inline void AddMemberRequest::clear_member_identity() { + if (member_identity_ != NULL) member_identity_->::bgs::protocol::Identity::Clear(); + clear_has_member_identity(); +} +inline const ::bgs::protocol::Identity& AddMemberRequest::member_identity() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.AddMemberRequest.member_identity) + return member_identity_ != NULL ? *member_identity_ : *default_instance_->member_identity_; +} +inline ::bgs::protocol::Identity* AddMemberRequest::mutable_member_identity() { + set_has_member_identity(); + if (member_identity_ == NULL) member_identity_ = new ::bgs::protocol::Identity; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.AddMemberRequest.member_identity) + return member_identity_; +} +inline ::bgs::protocol::Identity* AddMemberRequest::release_member_identity() { + clear_has_member_identity(); + ::bgs::protocol::Identity* temp = member_identity_; + member_identity_ = NULL; + return temp; +} +inline void AddMemberRequest::set_allocated_member_identity(::bgs::protocol::Identity* member_identity) { + delete member_identity_; + member_identity_ = member_identity; + if (member_identity) { + set_has_member_identity(); + } else { + clear_has_member_identity(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.AddMemberRequest.member_identity) +} + +// required .bgs.protocol.channel.v1.MemberState member_state = 3; +inline bool AddMemberRequest::has_member_state() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void AddMemberRequest::set_has_member_state() { + _has_bits_[0] |= 0x00000004u; +} +inline void AddMemberRequest::clear_has_member_state() { + _has_bits_[0] &= ~0x00000004u; +} +inline void AddMemberRequest::clear_member_state() { + if (member_state_ != NULL) member_state_->::bgs::protocol::channel::v1::MemberState::Clear(); + clear_has_member_state(); +} +inline const ::bgs::protocol::channel::v1::MemberState& AddMemberRequest::member_state() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.AddMemberRequest.member_state) + return member_state_ != NULL ? *member_state_ : *default_instance_->member_state_; +} +inline ::bgs::protocol::channel::v1::MemberState* AddMemberRequest::mutable_member_state() { + set_has_member_state(); + if (member_state_ == NULL) member_state_ = new ::bgs::protocol::channel::v1::MemberState; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.AddMemberRequest.member_state) + return member_state_; +} +inline ::bgs::protocol::channel::v1::MemberState* AddMemberRequest::release_member_state() { + clear_has_member_state(); + ::bgs::protocol::channel::v1::MemberState* temp = member_state_; + member_state_ = NULL; + return temp; +} +inline void AddMemberRequest::set_allocated_member_state(::bgs::protocol::channel::v1::MemberState* member_state) { + delete member_state_; + member_state_ = member_state; + if (member_state) { + set_has_member_state(); + } else { + clear_has_member_state(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.AddMemberRequest.member_state) +} + +// required uint64 object_id = 4; +inline bool AddMemberRequest::has_object_id() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void AddMemberRequest::set_has_object_id() { + _has_bits_[0] |= 0x00000008u; +} +inline void AddMemberRequest::clear_has_object_id() { + _has_bits_[0] &= ~0x00000008u; +} +inline void AddMemberRequest::clear_object_id() { + object_id_ = GOOGLE_ULONGLONG(0); + clear_has_object_id(); +} +inline ::google::protobuf::uint64 AddMemberRequest::object_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.AddMemberRequest.object_id) + return object_id_; +} +inline void AddMemberRequest::set_object_id(::google::protobuf::uint64 value) { + set_has_object_id(); + object_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.AddMemberRequest.object_id) +} + +// optional bool subscribe = 5 [default = true]; +inline bool AddMemberRequest::has_subscribe() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void AddMemberRequest::set_has_subscribe() { + _has_bits_[0] |= 0x00000010u; +} +inline void AddMemberRequest::clear_has_subscribe() { + _has_bits_[0] &= ~0x00000010u; +} +inline void AddMemberRequest::clear_subscribe() { + subscribe_ = true; + clear_has_subscribe(); +} +inline bool AddMemberRequest::subscribe() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.AddMemberRequest.subscribe) + return subscribe_; +} +inline void AddMemberRequest::set_subscribe(bool value) { + set_has_subscribe(); + subscribe_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.AddMemberRequest.subscribe) +} + +// ------------------------------------------------------------------- + +// RemoveMemberRequest + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool RemoveMemberRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void RemoveMemberRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void RemoveMemberRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void RemoveMemberRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& RemoveMemberRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.RemoveMemberRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* RemoveMemberRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.RemoveMemberRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* RemoveMemberRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void RemoveMemberRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.RemoveMemberRequest.agent_id) +} + +// required .bgs.protocol.EntityId member_id = 2; +inline bool RemoveMemberRequest::has_member_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void RemoveMemberRequest::set_has_member_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void RemoveMemberRequest::clear_has_member_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void RemoveMemberRequest::clear_member_id() { + if (member_id_ != NULL) member_id_->::bgs::protocol::EntityId::Clear(); + clear_has_member_id(); +} +inline const ::bgs::protocol::EntityId& RemoveMemberRequest::member_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.RemoveMemberRequest.member_id) + return member_id_ != NULL ? *member_id_ : *default_instance_->member_id_; +} +inline ::bgs::protocol::EntityId* RemoveMemberRequest::mutable_member_id() { + set_has_member_id(); + if (member_id_ == NULL) member_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.RemoveMemberRequest.member_id) + return member_id_; +} +inline ::bgs::protocol::EntityId* RemoveMemberRequest::release_member_id() { + clear_has_member_id(); + ::bgs::protocol::EntityId* temp = member_id_; + member_id_ = NULL; + return temp; +} +inline void RemoveMemberRequest::set_allocated_member_id(::bgs::protocol::EntityId* member_id) { + delete member_id_; + member_id_ = member_id; + if (member_id) { + set_has_member_id(); + } else { + clear_has_member_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.RemoveMemberRequest.member_id) +} + +// optional uint32 reason = 3; +inline bool RemoveMemberRequest::has_reason() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void RemoveMemberRequest::set_has_reason() { + _has_bits_[0] |= 0x00000004u; +} +inline void RemoveMemberRequest::clear_has_reason() { + _has_bits_[0] &= ~0x00000004u; +} +inline void RemoveMemberRequest::clear_reason() { + reason_ = 0u; + clear_has_reason(); +} +inline ::google::protobuf::uint32 RemoveMemberRequest::reason() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.RemoveMemberRequest.reason) + return reason_; +} +inline void RemoveMemberRequest::set_reason(::google::protobuf::uint32 value) { + set_has_reason(); + reason_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.RemoveMemberRequest.reason) +} + +// ------------------------------------------------------------------- + +// UnsubscribeMemberRequest + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool UnsubscribeMemberRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void UnsubscribeMemberRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void UnsubscribeMemberRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void UnsubscribeMemberRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& UnsubscribeMemberRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UnsubscribeMemberRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* UnsubscribeMemberRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UnsubscribeMemberRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* UnsubscribeMemberRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void UnsubscribeMemberRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UnsubscribeMemberRequest.agent_id) +} + +// required .bgs.protocol.EntityId member_id = 2; +inline bool UnsubscribeMemberRequest::has_member_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void UnsubscribeMemberRequest::set_has_member_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void UnsubscribeMemberRequest::clear_has_member_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void UnsubscribeMemberRequest::clear_member_id() { + if (member_id_ != NULL) member_id_->::bgs::protocol::EntityId::Clear(); + clear_has_member_id(); +} +inline const ::bgs::protocol::EntityId& UnsubscribeMemberRequest::member_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UnsubscribeMemberRequest.member_id) + return member_id_ != NULL ? *member_id_ : *default_instance_->member_id_; +} +inline ::bgs::protocol::EntityId* UnsubscribeMemberRequest::mutable_member_id() { + set_has_member_id(); + if (member_id_ == NULL) member_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UnsubscribeMemberRequest.member_id) + return member_id_; +} +inline ::bgs::protocol::EntityId* UnsubscribeMemberRequest::release_member_id() { + clear_has_member_id(); + ::bgs::protocol::EntityId* temp = member_id_; + member_id_ = NULL; + return temp; +} +inline void UnsubscribeMemberRequest::set_allocated_member_id(::bgs::protocol::EntityId* member_id) { + delete member_id_; + member_id_ = member_id; + if (member_id) { + set_has_member_id(); + } else { + clear_has_member_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UnsubscribeMemberRequest.member_id) +} + +// ------------------------------------------------------------------- + +// SendMessageRequest + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool SendMessageRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SendMessageRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void SendMessageRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SendMessageRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& SendMessageRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* SendMessageRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SendMessageRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* SendMessageRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void SendMessageRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SendMessageRequest.agent_id) +} + +// required .bgs.protocol.channel.v1.Message message = 2; +inline bool SendMessageRequest::has_message() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void SendMessageRequest::set_has_message() { + _has_bits_[0] |= 0x00000002u; +} +inline void SendMessageRequest::clear_has_message() { + _has_bits_[0] &= ~0x00000002u; +} +inline void SendMessageRequest::clear_message() { + if (message_ != NULL) message_->::bgs::protocol::channel::v1::Message::Clear(); + clear_has_message(); +} +inline const ::bgs::protocol::channel::v1::Message& SendMessageRequest::message() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageRequest.message) + return message_ != NULL ? *message_ : *default_instance_->message_; +} +inline ::bgs::protocol::channel::v1::Message* SendMessageRequest::mutable_message() { + set_has_message(); + if (message_ == NULL) message_ = new ::bgs::protocol::channel::v1::Message; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SendMessageRequest.message) + return message_; +} +inline ::bgs::protocol::channel::v1::Message* SendMessageRequest::release_message() { + clear_has_message(); + ::bgs::protocol::channel::v1::Message* temp = message_; + message_ = NULL; + return temp; +} +inline void SendMessageRequest::set_allocated_message(::bgs::protocol::channel::v1::Message* message) { + delete message_; + message_ = message; + if (message) { + set_has_message(); + } else { + clear_has_message(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SendMessageRequest.message) +} + +// optional uint64 required_privileges = 3 [default = 0]; +inline bool SendMessageRequest::has_required_privileges() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void SendMessageRequest::set_has_required_privileges() { + _has_bits_[0] |= 0x00000004u; +} +inline void SendMessageRequest::clear_has_required_privileges() { + _has_bits_[0] &= ~0x00000004u; +} +inline void SendMessageRequest::clear_required_privileges() { + required_privileges_ = GOOGLE_ULONGLONG(0); + clear_has_required_privileges(); +} +inline ::google::protobuf::uint64 SendMessageRequest::required_privileges() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageRequest.required_privileges) + return required_privileges_; +} +inline void SendMessageRequest::set_required_privileges(::google::protobuf::uint64 value) { + set_has_required_privileges(); + required_privileges_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.SendMessageRequest.required_privileges) +} + +// ------------------------------------------------------------------- + +// UpdateChannelStateRequest + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool UpdateChannelStateRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void UpdateChannelStateRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void UpdateChannelStateRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void UpdateChannelStateRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& UpdateChannelStateRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateChannelStateRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* UpdateChannelStateRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateChannelStateRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* UpdateChannelStateRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void UpdateChannelStateRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateChannelStateRequest.agent_id) +} + +// required .bgs.protocol.channel.v1.ChannelState state_change = 2; +inline bool UpdateChannelStateRequest::has_state_change() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void UpdateChannelStateRequest::set_has_state_change() { + _has_bits_[0] |= 0x00000002u; +} +inline void UpdateChannelStateRequest::clear_has_state_change() { + _has_bits_[0] &= ~0x00000002u; +} +inline void UpdateChannelStateRequest::clear_state_change() { + if (state_change_ != NULL) state_change_->::bgs::protocol::channel::v1::ChannelState::Clear(); + clear_has_state_change(); +} +inline const ::bgs::protocol::channel::v1::ChannelState& UpdateChannelStateRequest::state_change() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateChannelStateRequest.state_change) + return state_change_ != NULL ? *state_change_ : *default_instance_->state_change_; +} +inline ::bgs::protocol::channel::v1::ChannelState* UpdateChannelStateRequest::mutable_state_change() { + set_has_state_change(); + if (state_change_ == NULL) state_change_ = new ::bgs::protocol::channel::v1::ChannelState; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateChannelStateRequest.state_change) + return state_change_; +} +inline ::bgs::protocol::channel::v1::ChannelState* UpdateChannelStateRequest::release_state_change() { + clear_has_state_change(); + ::bgs::protocol::channel::v1::ChannelState* temp = state_change_; + state_change_ = NULL; + return temp; +} +inline void UpdateChannelStateRequest::set_allocated_state_change(::bgs::protocol::channel::v1::ChannelState* state_change) { + delete state_change_; + state_change_ = state_change; + if (state_change) { + set_has_state_change(); + } else { + clear_has_state_change(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateChannelStateRequest.state_change) +} + +// ------------------------------------------------------------------- + +// UpdateMemberStateRequest + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool UpdateMemberStateRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void UpdateMemberStateRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void UpdateMemberStateRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void UpdateMemberStateRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& UpdateMemberStateRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateMemberStateRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* UpdateMemberStateRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateMemberStateRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* UpdateMemberStateRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void UpdateMemberStateRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateMemberStateRequest.agent_id) +} + +// repeated .bgs.protocol.channel.v1.Member state_change = 2; +inline int UpdateMemberStateRequest::state_change_size() const { + return state_change_.size(); +} +inline void UpdateMemberStateRequest::clear_state_change() { + state_change_.Clear(); +} +inline const ::bgs::protocol::channel::v1::Member& UpdateMemberStateRequest::state_change(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateMemberStateRequest.state_change) + return state_change_.Get(index); +} +inline ::bgs::protocol::channel::v1::Member* UpdateMemberStateRequest::mutable_state_change(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateMemberStateRequest.state_change) + return state_change_.Mutable(index); +} +inline ::bgs::protocol::channel::v1::Member* UpdateMemberStateRequest::add_state_change() { + // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.UpdateMemberStateRequest.state_change) + return state_change_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >& +UpdateMemberStateRequest::state_change() const { + // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.UpdateMemberStateRequest.state_change) + return state_change_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >* +UpdateMemberStateRequest::mutable_state_change() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.UpdateMemberStateRequest.state_change) + return &state_change_; +} + +// repeated uint32 removed_role = 3 [packed = true]; +inline int UpdateMemberStateRequest::removed_role_size() const { + return removed_role_.size(); +} +inline void UpdateMemberStateRequest::clear_removed_role() { + removed_role_.Clear(); +} +inline ::google::protobuf::uint32 UpdateMemberStateRequest::removed_role(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateMemberStateRequest.removed_role) + return removed_role_.Get(index); +} +inline void UpdateMemberStateRequest::set_removed_role(int index, ::google::protobuf::uint32 value) { + removed_role_.Set(index, value); + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.UpdateMemberStateRequest.removed_role) +} +inline void UpdateMemberStateRequest::add_removed_role(::google::protobuf::uint32 value) { + removed_role_.Add(value); + // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.UpdateMemberStateRequest.removed_role) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +UpdateMemberStateRequest::removed_role() const { + // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.UpdateMemberStateRequest.removed_role) + return removed_role_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +UpdateMemberStateRequest::mutable_removed_role() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.UpdateMemberStateRequest.removed_role) + return &removed_role_; +} + +// ------------------------------------------------------------------- + +// DissolveRequest + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool DissolveRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void DissolveRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void DissolveRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void DissolveRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& DissolveRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.DissolveRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* DissolveRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.DissolveRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* DissolveRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void DissolveRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.DissolveRequest.agent_id) +} + +// optional uint32 reason = 2; +inline bool DissolveRequest::has_reason() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void DissolveRequest::set_has_reason() { + _has_bits_[0] |= 0x00000002u; +} +inline void DissolveRequest::clear_has_reason() { + _has_bits_[0] &= ~0x00000002u; +} +inline void DissolveRequest::clear_reason() { + reason_ = 0u; + clear_has_reason(); +} +inline ::google::protobuf::uint32 DissolveRequest::reason() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.DissolveRequest.reason) + return reason_; +} +inline void DissolveRequest::set_reason(::google::protobuf::uint32 value) { + set_has_reason(); + reason_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.DissolveRequest.reason) +} + +// ------------------------------------------------------------------- + +// SetRolesRequest + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool SetRolesRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SetRolesRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void SetRolesRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SetRolesRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& SetRolesRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SetRolesRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* SetRolesRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SetRolesRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* SetRolesRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void SetRolesRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SetRolesRequest.agent_id) +} + +// repeated uint32 role = 2 [packed = true]; +inline int SetRolesRequest::role_size() const { + return role_.size(); +} +inline void SetRolesRequest::clear_role() { + role_.Clear(); +} +inline ::google::protobuf::uint32 SetRolesRequest::role(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SetRolesRequest.role) + return role_.Get(index); +} +inline void SetRolesRequest::set_role(int index, ::google::protobuf::uint32 value) { + role_.Set(index, value); + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.SetRolesRequest.role) +} +inline void SetRolesRequest::add_role(::google::protobuf::uint32 value) { + role_.Add(value); + // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.SetRolesRequest.role) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +SetRolesRequest::role() const { + // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.SetRolesRequest.role) + return role_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +SetRolesRequest::mutable_role() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.SetRolesRequest.role) + return &role_; +} + +// repeated .bgs.protocol.EntityId member_id = 3; +inline int SetRolesRequest::member_id_size() const { + return member_id_.size(); +} +inline void SetRolesRequest::clear_member_id() { + member_id_.Clear(); +} +inline const ::bgs::protocol::EntityId& SetRolesRequest::member_id(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SetRolesRequest.member_id) + return member_id_.Get(index); +} +inline ::bgs::protocol::EntityId* SetRolesRequest::mutable_member_id(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SetRolesRequest.member_id) + return member_id_.Mutable(index); +} +inline ::bgs::protocol::EntityId* SetRolesRequest::add_member_id() { + // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.SetRolesRequest.member_id) + return member_id_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId >& +SetRolesRequest::member_id() const { + // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.SetRolesRequest.member_id) + return member_id_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId >* +SetRolesRequest::mutable_member_id() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.SetRolesRequest.member_id) + return &member_id_; +} + +// ------------------------------------------------------------------- + +// JoinNotification + +// optional .bgs.protocol.channel.v1.Member self = 1; +inline bool JoinNotification::has_self() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void JoinNotification::set_has_self() { + _has_bits_[0] |= 0x00000001u; +} +inline void JoinNotification::clear_has_self() { + _has_bits_[0] &= ~0x00000001u; +} +inline void JoinNotification::clear_self() { + if (self_ != NULL) self_->::bgs::protocol::channel::v1::Member::Clear(); + clear_has_self(); +} +inline const ::bgs::protocol::channel::v1::Member& JoinNotification::self() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.JoinNotification.self) + return self_ != NULL ? *self_ : *default_instance_->self_; +} +inline ::bgs::protocol::channel::v1::Member* JoinNotification::mutable_self() { + set_has_self(); + if (self_ == NULL) self_ = new ::bgs::protocol::channel::v1::Member; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.JoinNotification.self) + return self_; +} +inline ::bgs::protocol::channel::v1::Member* JoinNotification::release_self() { + clear_has_self(); + ::bgs::protocol::channel::v1::Member* temp = self_; + self_ = NULL; + return temp; +} +inline void JoinNotification::set_allocated_self(::bgs::protocol::channel::v1::Member* self) { + delete self_; + self_ = self; + if (self) { + set_has_self(); + } else { + clear_has_self(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.JoinNotification.self) +} + +// repeated .bgs.protocol.channel.v1.Member member = 2; +inline int JoinNotification::member_size() const { + return member_.size(); +} +inline void JoinNotification::clear_member() { + member_.Clear(); +} +inline const ::bgs::protocol::channel::v1::Member& JoinNotification::member(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.JoinNotification.member) + return member_.Get(index); +} +inline ::bgs::protocol::channel::v1::Member* JoinNotification::mutable_member(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.JoinNotification.member) + return member_.Mutable(index); +} +inline ::bgs::protocol::channel::v1::Member* JoinNotification::add_member() { + // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.JoinNotification.member) + return member_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >& +JoinNotification::member() const { + // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.JoinNotification.member) + return member_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >* +JoinNotification::mutable_member() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.JoinNotification.member) + return &member_; +} + +// required .bgs.protocol.channel.v1.ChannelState channel_state = 3; +inline bool JoinNotification::has_channel_state() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void JoinNotification::set_has_channel_state() { + _has_bits_[0] |= 0x00000004u; +} +inline void JoinNotification::clear_has_channel_state() { + _has_bits_[0] &= ~0x00000004u; +} +inline void JoinNotification::clear_channel_state() { + if (channel_state_ != NULL) channel_state_->::bgs::protocol::channel::v1::ChannelState::Clear(); + clear_has_channel_state(); +} +inline const ::bgs::protocol::channel::v1::ChannelState& JoinNotification::channel_state() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.JoinNotification.channel_state) + return channel_state_ != NULL ? *channel_state_ : *default_instance_->channel_state_; +} +inline ::bgs::protocol::channel::v1::ChannelState* JoinNotification::mutable_channel_state() { + set_has_channel_state(); + if (channel_state_ == NULL) channel_state_ = new ::bgs::protocol::channel::v1::ChannelState; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.JoinNotification.channel_state) + return channel_state_; +} +inline ::bgs::protocol::channel::v1::ChannelState* JoinNotification::release_channel_state() { + clear_has_channel_state(); + ::bgs::protocol::channel::v1::ChannelState* temp = channel_state_; + channel_state_ = NULL; + return temp; +} +inline void JoinNotification::set_allocated_channel_state(::bgs::protocol::channel::v1::ChannelState* channel_state) { + delete channel_state_; + channel_state_ = channel_state; + if (channel_state) { + set_has_channel_state(); + } else { + clear_has_channel_state(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.JoinNotification.channel_state) +} + +// optional .bgs.protocol.channel.v1.ChannelId channel_id = 4; +inline bool JoinNotification::has_channel_id() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void JoinNotification::set_has_channel_id() { + _has_bits_[0] |= 0x00000008u; +} +inline void JoinNotification::clear_has_channel_id() { + _has_bits_[0] &= ~0x00000008u; +} +inline void JoinNotification::clear_channel_id() { + if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear(); + clear_has_channel_id(); +} +inline const ::bgs::protocol::channel::v1::ChannelId& JoinNotification::channel_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.JoinNotification.channel_id) + return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_; +} +inline ::bgs::protocol::channel::v1::ChannelId* JoinNotification::mutable_channel_id() { + set_has_channel_id(); + if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::channel::v1::ChannelId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.JoinNotification.channel_id) + return channel_id_; +} +inline ::bgs::protocol::channel::v1::ChannelId* JoinNotification::release_channel_id() { + clear_has_channel_id(); + ::bgs::protocol::channel::v1::ChannelId* temp = channel_id_; + channel_id_ = NULL; + return temp; +} +inline void JoinNotification::set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id) { + delete channel_id_; + channel_id_ = channel_id; + if (channel_id) { + set_has_channel_id(); + } else { + clear_has_channel_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.JoinNotification.channel_id) +} + +// optional .bgs.protocol.account.v1.Identity subscriber = 5; +inline bool JoinNotification::has_subscriber() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void JoinNotification::set_has_subscriber() { + _has_bits_[0] |= 0x00000010u; +} +inline void JoinNotification::clear_has_subscriber() { + _has_bits_[0] &= ~0x00000010u; +} +inline void JoinNotification::clear_subscriber() { + if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear(); + clear_has_subscriber(); +} +inline const ::bgs::protocol::account::v1::Identity& JoinNotification::subscriber() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.JoinNotification.subscriber) + return subscriber_ != NULL ? *subscriber_ : *default_instance_->subscriber_; +} +inline ::bgs::protocol::account::v1::Identity* JoinNotification::mutable_subscriber() { + set_has_subscriber(); + if (subscriber_ == NULL) subscriber_ = new ::bgs::protocol::account::v1::Identity; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.JoinNotification.subscriber) + return subscriber_; +} +inline ::bgs::protocol::account::v1::Identity* JoinNotification::release_subscriber() { + clear_has_subscriber(); + ::bgs::protocol::account::v1::Identity* temp = subscriber_; + subscriber_ = NULL; + return temp; +} +inline void JoinNotification::set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber) { + delete subscriber_; + subscriber_ = subscriber; + if (subscriber) { + set_has_subscriber(); + } else { + clear_has_subscriber(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.JoinNotification.subscriber) +} + +// ------------------------------------------------------------------- + +// MemberAddedNotification + +// required .bgs.protocol.channel.v1.Member member = 1; +inline bool MemberAddedNotification::has_member() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void MemberAddedNotification::set_has_member() { + _has_bits_[0] |= 0x00000001u; +} +inline void MemberAddedNotification::clear_has_member() { + _has_bits_[0] &= ~0x00000001u; +} +inline void MemberAddedNotification::clear_member() { + if (member_ != NULL) member_->::bgs::protocol::channel::v1::Member::Clear(); + clear_has_member(); +} +inline const ::bgs::protocol::channel::v1::Member& MemberAddedNotification::member() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberAddedNotification.member) + return member_ != NULL ? *member_ : *default_instance_->member_; +} +inline ::bgs::protocol::channel::v1::Member* MemberAddedNotification::mutable_member() { + set_has_member(); + if (member_ == NULL) member_ = new ::bgs::protocol::channel::v1::Member; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberAddedNotification.member) + return member_; +} +inline ::bgs::protocol::channel::v1::Member* MemberAddedNotification::release_member() { + clear_has_member(); + ::bgs::protocol::channel::v1::Member* temp = member_; + member_ = NULL; + return temp; +} +inline void MemberAddedNotification::set_allocated_member(::bgs::protocol::channel::v1::Member* member) { + delete member_; + member_ = member; + if (member) { + set_has_member(); + } else { + clear_has_member(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.MemberAddedNotification.member) +} + +// optional .bgs.protocol.channel.v1.ChannelId channel_id = 2; +inline bool MemberAddedNotification::has_channel_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void MemberAddedNotification::set_has_channel_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void MemberAddedNotification::clear_has_channel_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void MemberAddedNotification::clear_channel_id() { + if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear(); + clear_has_channel_id(); +} +inline const ::bgs::protocol::channel::v1::ChannelId& MemberAddedNotification::channel_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberAddedNotification.channel_id) + return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_; +} +inline ::bgs::protocol::channel::v1::ChannelId* MemberAddedNotification::mutable_channel_id() { + set_has_channel_id(); + if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::channel::v1::ChannelId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberAddedNotification.channel_id) + return channel_id_; +} +inline ::bgs::protocol::channel::v1::ChannelId* MemberAddedNotification::release_channel_id() { + clear_has_channel_id(); + ::bgs::protocol::channel::v1::ChannelId* temp = channel_id_; + channel_id_ = NULL; + return temp; +} +inline void MemberAddedNotification::set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id) { + delete channel_id_; + channel_id_ = channel_id; + if (channel_id) { + set_has_channel_id(); + } else { + clear_has_channel_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.MemberAddedNotification.channel_id) +} + +// optional .bgs.protocol.account.v1.Identity subscriber = 3; +inline bool MemberAddedNotification::has_subscriber() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void MemberAddedNotification::set_has_subscriber() { + _has_bits_[0] |= 0x00000004u; +} +inline void MemberAddedNotification::clear_has_subscriber() { + _has_bits_[0] &= ~0x00000004u; +} +inline void MemberAddedNotification::clear_subscriber() { + if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear(); + clear_has_subscriber(); +} +inline const ::bgs::protocol::account::v1::Identity& MemberAddedNotification::subscriber() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberAddedNotification.subscriber) + return subscriber_ != NULL ? *subscriber_ : *default_instance_->subscriber_; +} +inline ::bgs::protocol::account::v1::Identity* MemberAddedNotification::mutable_subscriber() { + set_has_subscriber(); + if (subscriber_ == NULL) subscriber_ = new ::bgs::protocol::account::v1::Identity; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberAddedNotification.subscriber) + return subscriber_; +} +inline ::bgs::protocol::account::v1::Identity* MemberAddedNotification::release_subscriber() { + clear_has_subscriber(); + ::bgs::protocol::account::v1::Identity* temp = subscriber_; + subscriber_ = NULL; + return temp; +} +inline void MemberAddedNotification::set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber) { + delete subscriber_; + subscriber_ = subscriber; + if (subscriber) { + set_has_subscriber(); + } else { + clear_has_subscriber(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.MemberAddedNotification.subscriber) +} + +// ------------------------------------------------------------------- + +// LeaveNotification + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool LeaveNotification::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void LeaveNotification::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void LeaveNotification::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void LeaveNotification::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& LeaveNotification::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.LeaveNotification.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* LeaveNotification::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.LeaveNotification.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* LeaveNotification::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void LeaveNotification::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.LeaveNotification.agent_id) +} + +// required .bgs.protocol.EntityId member_id = 2; +inline bool LeaveNotification::has_member_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void LeaveNotification::set_has_member_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void LeaveNotification::clear_has_member_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void LeaveNotification::clear_member_id() { + if (member_id_ != NULL) member_id_->::bgs::protocol::EntityId::Clear(); + clear_has_member_id(); +} +inline const ::bgs::protocol::EntityId& LeaveNotification::member_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.LeaveNotification.member_id) + return member_id_ != NULL ? *member_id_ : *default_instance_->member_id_; +} +inline ::bgs::protocol::EntityId* LeaveNotification::mutable_member_id() { + set_has_member_id(); + if (member_id_ == NULL) member_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.LeaveNotification.member_id) + return member_id_; +} +inline ::bgs::protocol::EntityId* LeaveNotification::release_member_id() { + clear_has_member_id(); + ::bgs::protocol::EntityId* temp = member_id_; + member_id_ = NULL; + return temp; +} +inline void LeaveNotification::set_allocated_member_id(::bgs::protocol::EntityId* member_id) { + delete member_id_; + member_id_ = member_id; + if (member_id) { + set_has_member_id(); + } else { + clear_has_member_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.LeaveNotification.member_id) +} + +// optional uint32 reason = 3; +inline bool LeaveNotification::has_reason() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void LeaveNotification::set_has_reason() { + _has_bits_[0] |= 0x00000004u; +} +inline void LeaveNotification::clear_has_reason() { + _has_bits_[0] &= ~0x00000004u; +} +inline void LeaveNotification::clear_reason() { + reason_ = 0u; + clear_has_reason(); +} +inline ::google::protobuf::uint32 LeaveNotification::reason() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.LeaveNotification.reason) + return reason_; +} +inline void LeaveNotification::set_reason(::google::protobuf::uint32 value) { + set_has_reason(); + reason_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.LeaveNotification.reason) +} + +// optional .bgs.protocol.channel.v1.ChannelId channel_id = 4; +inline bool LeaveNotification::has_channel_id() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void LeaveNotification::set_has_channel_id() { + _has_bits_[0] |= 0x00000008u; +} +inline void LeaveNotification::clear_has_channel_id() { + _has_bits_[0] &= ~0x00000008u; +} +inline void LeaveNotification::clear_channel_id() { + if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear(); + clear_has_channel_id(); +} +inline const ::bgs::protocol::channel::v1::ChannelId& LeaveNotification::channel_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.LeaveNotification.channel_id) + return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_; +} +inline ::bgs::protocol::channel::v1::ChannelId* LeaveNotification::mutable_channel_id() { + set_has_channel_id(); + if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::channel::v1::ChannelId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.LeaveNotification.channel_id) + return channel_id_; +} +inline ::bgs::protocol::channel::v1::ChannelId* LeaveNotification::release_channel_id() { + clear_has_channel_id(); + ::bgs::protocol::channel::v1::ChannelId* temp = channel_id_; + channel_id_ = NULL; + return temp; +} +inline void LeaveNotification::set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id) { + delete channel_id_; + channel_id_ = channel_id; + if (channel_id) { + set_has_channel_id(); + } else { + clear_has_channel_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.LeaveNotification.channel_id) +} + +// optional .bgs.protocol.account.v1.Identity subscriber = 5; +inline bool LeaveNotification::has_subscriber() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void LeaveNotification::set_has_subscriber() { + _has_bits_[0] |= 0x00000010u; +} +inline void LeaveNotification::clear_has_subscriber() { + _has_bits_[0] &= ~0x00000010u; +} +inline void LeaveNotification::clear_subscriber() { + if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear(); + clear_has_subscriber(); +} +inline const ::bgs::protocol::account::v1::Identity& LeaveNotification::subscriber() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.LeaveNotification.subscriber) + return subscriber_ != NULL ? *subscriber_ : *default_instance_->subscriber_; +} +inline ::bgs::protocol::account::v1::Identity* LeaveNotification::mutable_subscriber() { + set_has_subscriber(); + if (subscriber_ == NULL) subscriber_ = new ::bgs::protocol::account::v1::Identity; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.LeaveNotification.subscriber) + return subscriber_; +} +inline ::bgs::protocol::account::v1::Identity* LeaveNotification::release_subscriber() { + clear_has_subscriber(); + ::bgs::protocol::account::v1::Identity* temp = subscriber_; + subscriber_ = NULL; + return temp; +} +inline void LeaveNotification::set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber) { + delete subscriber_; + subscriber_ = subscriber; + if (subscriber) { + set_has_subscriber(); + } else { + clear_has_subscriber(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.LeaveNotification.subscriber) +} + +// ------------------------------------------------------------------- + +// MemberRemovedNotification + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool MemberRemovedNotification::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void MemberRemovedNotification::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void MemberRemovedNotification::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void MemberRemovedNotification::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& MemberRemovedNotification::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberRemovedNotification.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* MemberRemovedNotification::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberRemovedNotification.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* MemberRemovedNotification::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void MemberRemovedNotification::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.MemberRemovedNotification.agent_id) +} + +// required .bgs.protocol.EntityId member_id = 2; +inline bool MemberRemovedNotification::has_member_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void MemberRemovedNotification::set_has_member_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void MemberRemovedNotification::clear_has_member_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void MemberRemovedNotification::clear_member_id() { + if (member_id_ != NULL) member_id_->::bgs::protocol::EntityId::Clear(); + clear_has_member_id(); +} +inline const ::bgs::protocol::EntityId& MemberRemovedNotification::member_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberRemovedNotification.member_id) + return member_id_ != NULL ? *member_id_ : *default_instance_->member_id_; +} +inline ::bgs::protocol::EntityId* MemberRemovedNotification::mutable_member_id() { + set_has_member_id(); + if (member_id_ == NULL) member_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberRemovedNotification.member_id) + return member_id_; +} +inline ::bgs::protocol::EntityId* MemberRemovedNotification::release_member_id() { + clear_has_member_id(); + ::bgs::protocol::EntityId* temp = member_id_; + member_id_ = NULL; + return temp; +} +inline void MemberRemovedNotification::set_allocated_member_id(::bgs::protocol::EntityId* member_id) { + delete member_id_; + member_id_ = member_id; + if (member_id) { + set_has_member_id(); + } else { + clear_has_member_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.MemberRemovedNotification.member_id) +} + +// optional uint32 reason = 3; +inline bool MemberRemovedNotification::has_reason() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void MemberRemovedNotification::set_has_reason() { + _has_bits_[0] |= 0x00000004u; +} +inline void MemberRemovedNotification::clear_has_reason() { + _has_bits_[0] &= ~0x00000004u; +} +inline void MemberRemovedNotification::clear_reason() { + reason_ = 0u; + clear_has_reason(); +} +inline ::google::protobuf::uint32 MemberRemovedNotification::reason() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberRemovedNotification.reason) + return reason_; +} +inline void MemberRemovedNotification::set_reason(::google::protobuf::uint32 value) { + set_has_reason(); + reason_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.MemberRemovedNotification.reason) +} + +// optional .bgs.protocol.channel.v1.ChannelId channel_id = 4; +inline bool MemberRemovedNotification::has_channel_id() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void MemberRemovedNotification::set_has_channel_id() { + _has_bits_[0] |= 0x00000008u; +} +inline void MemberRemovedNotification::clear_has_channel_id() { + _has_bits_[0] &= ~0x00000008u; +} +inline void MemberRemovedNotification::clear_channel_id() { + if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear(); + clear_has_channel_id(); +} +inline const ::bgs::protocol::channel::v1::ChannelId& MemberRemovedNotification::channel_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberRemovedNotification.channel_id) + return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_; +} +inline ::bgs::protocol::channel::v1::ChannelId* MemberRemovedNotification::mutable_channel_id() { + set_has_channel_id(); + if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::channel::v1::ChannelId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberRemovedNotification.channel_id) + return channel_id_; +} +inline ::bgs::protocol::channel::v1::ChannelId* MemberRemovedNotification::release_channel_id() { + clear_has_channel_id(); + ::bgs::protocol::channel::v1::ChannelId* temp = channel_id_; + channel_id_ = NULL; + return temp; +} +inline void MemberRemovedNotification::set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id) { + delete channel_id_; + channel_id_ = channel_id; + if (channel_id) { + set_has_channel_id(); + } else { + clear_has_channel_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.MemberRemovedNotification.channel_id) +} + +// optional .bgs.protocol.account.v1.Identity subscriber = 5; +inline bool MemberRemovedNotification::has_subscriber() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void MemberRemovedNotification::set_has_subscriber() { + _has_bits_[0] |= 0x00000010u; +} +inline void MemberRemovedNotification::clear_has_subscriber() { + _has_bits_[0] &= ~0x00000010u; +} +inline void MemberRemovedNotification::clear_subscriber() { + if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear(); + clear_has_subscriber(); +} +inline const ::bgs::protocol::account::v1::Identity& MemberRemovedNotification::subscriber() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberRemovedNotification.subscriber) + return subscriber_ != NULL ? *subscriber_ : *default_instance_->subscriber_; +} +inline ::bgs::protocol::account::v1::Identity* MemberRemovedNotification::mutable_subscriber() { + set_has_subscriber(); + if (subscriber_ == NULL) subscriber_ = new ::bgs::protocol::account::v1::Identity; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberRemovedNotification.subscriber) + return subscriber_; +} +inline ::bgs::protocol::account::v1::Identity* MemberRemovedNotification::release_subscriber() { + clear_has_subscriber(); + ::bgs::protocol::account::v1::Identity* temp = subscriber_; + subscriber_ = NULL; + return temp; +} +inline void MemberRemovedNotification::set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber) { + delete subscriber_; + subscriber_ = subscriber; + if (subscriber) { + set_has_subscriber(); + } else { + clear_has_subscriber(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.MemberRemovedNotification.subscriber) +} + +// ------------------------------------------------------------------- + +// SendMessageNotification + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool SendMessageNotification::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SendMessageNotification::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void SendMessageNotification::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SendMessageNotification::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& SendMessageNotification::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageNotification.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* SendMessageNotification::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SendMessageNotification.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* SendMessageNotification::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void SendMessageNotification::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SendMessageNotification.agent_id) +} + +// required .bgs.protocol.channel.v1.Message message = 2; +inline bool SendMessageNotification::has_message() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void SendMessageNotification::set_has_message() { + _has_bits_[0] |= 0x00000002u; +} +inline void SendMessageNotification::clear_has_message() { + _has_bits_[0] &= ~0x00000002u; +} +inline void SendMessageNotification::clear_message() { + if (message_ != NULL) message_->::bgs::protocol::channel::v1::Message::Clear(); + clear_has_message(); +} +inline const ::bgs::protocol::channel::v1::Message& SendMessageNotification::message() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageNotification.message) + return message_ != NULL ? *message_ : *default_instance_->message_; +} +inline ::bgs::protocol::channel::v1::Message* SendMessageNotification::mutable_message() { + set_has_message(); + if (message_ == NULL) message_ = new ::bgs::protocol::channel::v1::Message; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SendMessageNotification.message) + return message_; +} +inline ::bgs::protocol::channel::v1::Message* SendMessageNotification::release_message() { + clear_has_message(); + ::bgs::protocol::channel::v1::Message* temp = message_; + message_ = NULL; + return temp; +} +inline void SendMessageNotification::set_allocated_message(::bgs::protocol::channel::v1::Message* message) { + delete message_; + message_ = message; + if (message) { + set_has_message(); + } else { + clear_has_message(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SendMessageNotification.message) +} + +// optional uint64 required_privileges = 3 [default = 0]; +inline bool SendMessageNotification::has_required_privileges() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void SendMessageNotification::set_has_required_privileges() { + _has_bits_[0] |= 0x00000004u; +} +inline void SendMessageNotification::clear_has_required_privileges() { + _has_bits_[0] &= ~0x00000004u; +} +inline void SendMessageNotification::clear_required_privileges() { + required_privileges_ = GOOGLE_ULONGLONG(0); + clear_has_required_privileges(); +} +inline ::google::protobuf::uint64 SendMessageNotification::required_privileges() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageNotification.required_privileges) + return required_privileges_; +} +inline void SendMessageNotification::set_required_privileges(::google::protobuf::uint64 value) { + set_has_required_privileges(); + required_privileges_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.SendMessageNotification.required_privileges) +} + +// optional string identity = 4; +inline bool SendMessageNotification::has_identity() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void SendMessageNotification::set_has_identity() { + _has_bits_[0] |= 0x00000008u; +} +inline void SendMessageNotification::clear_has_identity() { + _has_bits_[0] &= ~0x00000008u; +} +inline void SendMessageNotification::clear_identity() { + if (identity_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + identity_->clear(); + } + clear_has_identity(); +} +inline const ::std::string& SendMessageNotification::identity() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageNotification.identity) + return *identity_; +} +inline void SendMessageNotification::set_identity(const ::std::string& value) { + set_has_identity(); + if (identity_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + identity_ = new ::std::string; + } + identity_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.SendMessageNotification.identity) +} +inline void SendMessageNotification::set_identity(const char* value) { + set_has_identity(); + if (identity_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + identity_ = new ::std::string; + } + identity_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.channel.v1.SendMessageNotification.identity) +} +inline void SendMessageNotification::set_identity(const char* value, size_t size) { + set_has_identity(); + if (identity_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + identity_ = new ::std::string; + } + identity_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.channel.v1.SendMessageNotification.identity) +} +inline ::std::string* SendMessageNotification::mutable_identity() { + set_has_identity(); + if (identity_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + identity_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SendMessageNotification.identity) + return identity_; +} +inline ::std::string* SendMessageNotification::release_identity() { + clear_has_identity(); + if (identity_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = identity_; + identity_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void SendMessageNotification::set_allocated_identity(::std::string* identity) { + if (identity_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete identity_; + } + if (identity) { + set_has_identity(); + identity_ = identity; + } else { + clear_has_identity(); + identity_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SendMessageNotification.identity) +} + +// optional .bgs.protocol.channel.v1.ChannelId channel_id = 5; +inline bool SendMessageNotification::has_channel_id() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void SendMessageNotification::set_has_channel_id() { + _has_bits_[0] |= 0x00000010u; +} +inline void SendMessageNotification::clear_has_channel_id() { + _has_bits_[0] &= ~0x00000010u; +} +inline void SendMessageNotification::clear_channel_id() { + if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear(); + clear_has_channel_id(); +} +inline const ::bgs::protocol::channel::v1::ChannelId& SendMessageNotification::channel_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageNotification.channel_id) + return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_; +} +inline ::bgs::protocol::channel::v1::ChannelId* SendMessageNotification::mutable_channel_id() { + set_has_channel_id(); + if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::channel::v1::ChannelId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SendMessageNotification.channel_id) + return channel_id_; +} +inline ::bgs::protocol::channel::v1::ChannelId* SendMessageNotification::release_channel_id() { + clear_has_channel_id(); + ::bgs::protocol::channel::v1::ChannelId* temp = channel_id_; + channel_id_ = NULL; + return temp; +} +inline void SendMessageNotification::set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id) { + delete channel_id_; + channel_id_ = channel_id; + if (channel_id) { + set_has_channel_id(); + } else { + clear_has_channel_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SendMessageNotification.channel_id) +} + +// optional .bgs.protocol.account.v1.Identity subscriber = 6; +inline bool SendMessageNotification::has_subscriber() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void SendMessageNotification::set_has_subscriber() { + _has_bits_[0] |= 0x00000020u; +} +inline void SendMessageNotification::clear_has_subscriber() { + _has_bits_[0] &= ~0x00000020u; +} +inline void SendMessageNotification::clear_subscriber() { + if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear(); + clear_has_subscriber(); +} +inline const ::bgs::protocol::account::v1::Identity& SendMessageNotification::subscriber() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageNotification.subscriber) + return subscriber_ != NULL ? *subscriber_ : *default_instance_->subscriber_; +} +inline ::bgs::protocol::account::v1::Identity* SendMessageNotification::mutable_subscriber() { + set_has_subscriber(); + if (subscriber_ == NULL) subscriber_ = new ::bgs::protocol::account::v1::Identity; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SendMessageNotification.subscriber) + return subscriber_; +} +inline ::bgs::protocol::account::v1::Identity* SendMessageNotification::release_subscriber() { + clear_has_subscriber(); + ::bgs::protocol::account::v1::Identity* temp = subscriber_; + subscriber_ = NULL; + return temp; +} +inline void SendMessageNotification::set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber) { + delete subscriber_; + subscriber_ = subscriber; + if (subscriber) { + set_has_subscriber(); + } else { + clear_has_subscriber(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SendMessageNotification.subscriber) +} + +// ------------------------------------------------------------------- + +// UpdateChannelStateNotification + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool UpdateChannelStateNotification::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void UpdateChannelStateNotification::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void UpdateChannelStateNotification::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void UpdateChannelStateNotification::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& UpdateChannelStateNotification::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateChannelStateNotification.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* UpdateChannelStateNotification::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateChannelStateNotification.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* UpdateChannelStateNotification::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void UpdateChannelStateNotification::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateChannelStateNotification.agent_id) +} + +// required .bgs.protocol.channel.v1.ChannelState state_change = 2; +inline bool UpdateChannelStateNotification::has_state_change() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void UpdateChannelStateNotification::set_has_state_change() { + _has_bits_[0] |= 0x00000002u; +} +inline void UpdateChannelStateNotification::clear_has_state_change() { + _has_bits_[0] &= ~0x00000002u; +} +inline void UpdateChannelStateNotification::clear_state_change() { + if (state_change_ != NULL) state_change_->::bgs::protocol::channel::v1::ChannelState::Clear(); + clear_has_state_change(); +} +inline const ::bgs::protocol::channel::v1::ChannelState& UpdateChannelStateNotification::state_change() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateChannelStateNotification.state_change) + return state_change_ != NULL ? *state_change_ : *default_instance_->state_change_; +} +inline ::bgs::protocol::channel::v1::ChannelState* UpdateChannelStateNotification::mutable_state_change() { + set_has_state_change(); + if (state_change_ == NULL) state_change_ = new ::bgs::protocol::channel::v1::ChannelState; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateChannelStateNotification.state_change) + return state_change_; +} +inline ::bgs::protocol::channel::v1::ChannelState* UpdateChannelStateNotification::release_state_change() { + clear_has_state_change(); + ::bgs::protocol::channel::v1::ChannelState* temp = state_change_; + state_change_ = NULL; + return temp; +} +inline void UpdateChannelStateNotification::set_allocated_state_change(::bgs::protocol::channel::v1::ChannelState* state_change) { + delete state_change_; + state_change_ = state_change; + if (state_change) { + set_has_state_change(); + } else { + clear_has_state_change(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateChannelStateNotification.state_change) +} + +// optional .bgs.protocol.channel.v1.ChannelId channel_id = 3; +inline bool UpdateChannelStateNotification::has_channel_id() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void UpdateChannelStateNotification::set_has_channel_id() { + _has_bits_[0] |= 0x00000004u; +} +inline void UpdateChannelStateNotification::clear_has_channel_id() { + _has_bits_[0] &= ~0x00000004u; +} +inline void UpdateChannelStateNotification::clear_channel_id() { + if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear(); + clear_has_channel_id(); +} +inline const ::bgs::protocol::channel::v1::ChannelId& UpdateChannelStateNotification::channel_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateChannelStateNotification.channel_id) + return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_; +} +inline ::bgs::protocol::channel::v1::ChannelId* UpdateChannelStateNotification::mutable_channel_id() { + set_has_channel_id(); + if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::channel::v1::ChannelId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateChannelStateNotification.channel_id) + return channel_id_; +} +inline ::bgs::protocol::channel::v1::ChannelId* UpdateChannelStateNotification::release_channel_id() { + clear_has_channel_id(); + ::bgs::protocol::channel::v1::ChannelId* temp = channel_id_; + channel_id_ = NULL; + return temp; +} +inline void UpdateChannelStateNotification::set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id) { + delete channel_id_; + channel_id_ = channel_id; + if (channel_id) { + set_has_channel_id(); + } else { + clear_has_channel_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateChannelStateNotification.channel_id) +} + +// optional .bgs.protocol.account.v1.Identity subscriber = 4; +inline bool UpdateChannelStateNotification::has_subscriber() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void UpdateChannelStateNotification::set_has_subscriber() { + _has_bits_[0] |= 0x00000008u; +} +inline void UpdateChannelStateNotification::clear_has_subscriber() { + _has_bits_[0] &= ~0x00000008u; +} +inline void UpdateChannelStateNotification::clear_subscriber() { + if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear(); + clear_has_subscriber(); +} +inline const ::bgs::protocol::account::v1::Identity& UpdateChannelStateNotification::subscriber() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateChannelStateNotification.subscriber) + return subscriber_ != NULL ? *subscriber_ : *default_instance_->subscriber_; +} +inline ::bgs::protocol::account::v1::Identity* UpdateChannelStateNotification::mutable_subscriber() { + set_has_subscriber(); + if (subscriber_ == NULL) subscriber_ = new ::bgs::protocol::account::v1::Identity; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateChannelStateNotification.subscriber) + return subscriber_; +} +inline ::bgs::protocol::account::v1::Identity* UpdateChannelStateNotification::release_subscriber() { + clear_has_subscriber(); + ::bgs::protocol::account::v1::Identity* temp = subscriber_; + subscriber_ = NULL; + return temp; +} +inline void UpdateChannelStateNotification::set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber) { + delete subscriber_; + subscriber_ = subscriber; + if (subscriber) { + set_has_subscriber(); + } else { + clear_has_subscriber(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateChannelStateNotification.subscriber) +} + +// ------------------------------------------------------------------- + +// UpdateMemberStateNotification + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool UpdateMemberStateNotification::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void UpdateMemberStateNotification::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void UpdateMemberStateNotification::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void UpdateMemberStateNotification::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& UpdateMemberStateNotification::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateMemberStateNotification.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* UpdateMemberStateNotification::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateMemberStateNotification.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* UpdateMemberStateNotification::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void UpdateMemberStateNotification::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateMemberStateNotification.agent_id) +} + +// repeated .bgs.protocol.channel.v1.Member state_change = 2; +inline int UpdateMemberStateNotification::state_change_size() const { + return state_change_.size(); +} +inline void UpdateMemberStateNotification::clear_state_change() { + state_change_.Clear(); +} +inline const ::bgs::protocol::channel::v1::Member& UpdateMemberStateNotification::state_change(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateMemberStateNotification.state_change) + return state_change_.Get(index); +} +inline ::bgs::protocol::channel::v1::Member* UpdateMemberStateNotification::mutable_state_change(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateMemberStateNotification.state_change) + return state_change_.Mutable(index); +} +inline ::bgs::protocol::channel::v1::Member* UpdateMemberStateNotification::add_state_change() { + // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.UpdateMemberStateNotification.state_change) + return state_change_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >& +UpdateMemberStateNotification::state_change() const { + // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.UpdateMemberStateNotification.state_change) + return state_change_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >* +UpdateMemberStateNotification::mutable_state_change() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.UpdateMemberStateNotification.state_change) + return &state_change_; +} + +// repeated uint32 removed_role = 3 [packed = true]; +inline int UpdateMemberStateNotification::removed_role_size() const { + return removed_role_.size(); +} +inline void UpdateMemberStateNotification::clear_removed_role() { + removed_role_.Clear(); +} +inline ::google::protobuf::uint32 UpdateMemberStateNotification::removed_role(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateMemberStateNotification.removed_role) + return removed_role_.Get(index); +} +inline void UpdateMemberStateNotification::set_removed_role(int index, ::google::protobuf::uint32 value) { + removed_role_.Set(index, value); + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.UpdateMemberStateNotification.removed_role) +} +inline void UpdateMemberStateNotification::add_removed_role(::google::protobuf::uint32 value) { + removed_role_.Add(value); + // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.UpdateMemberStateNotification.removed_role) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +UpdateMemberStateNotification::removed_role() const { + // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.UpdateMemberStateNotification.removed_role) + return removed_role_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +UpdateMemberStateNotification::mutable_removed_role() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.UpdateMemberStateNotification.removed_role) + return &removed_role_; +} + +// optional .bgs.protocol.channel.v1.ChannelId channel_id = 4; +inline bool UpdateMemberStateNotification::has_channel_id() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void UpdateMemberStateNotification::set_has_channel_id() { + _has_bits_[0] |= 0x00000008u; +} +inline void UpdateMemberStateNotification::clear_has_channel_id() { + _has_bits_[0] &= ~0x00000008u; +} +inline void UpdateMemberStateNotification::clear_channel_id() { + if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear(); + clear_has_channel_id(); +} +inline const ::bgs::protocol::channel::v1::ChannelId& UpdateMemberStateNotification::channel_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateMemberStateNotification.channel_id) + return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_; +} +inline ::bgs::protocol::channel::v1::ChannelId* UpdateMemberStateNotification::mutable_channel_id() { + set_has_channel_id(); + if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::channel::v1::ChannelId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateMemberStateNotification.channel_id) + return channel_id_; +} +inline ::bgs::protocol::channel::v1::ChannelId* UpdateMemberStateNotification::release_channel_id() { + clear_has_channel_id(); + ::bgs::protocol::channel::v1::ChannelId* temp = channel_id_; + channel_id_ = NULL; + return temp; +} +inline void UpdateMemberStateNotification::set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id) { + delete channel_id_; + channel_id_ = channel_id; + if (channel_id) { + set_has_channel_id(); + } else { + clear_has_channel_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateMemberStateNotification.channel_id) +} + +// optional .bgs.protocol.account.v1.Identity subscriber = 5; +inline bool UpdateMemberStateNotification::has_subscriber() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void UpdateMemberStateNotification::set_has_subscriber() { + _has_bits_[0] |= 0x00000010u; +} +inline void UpdateMemberStateNotification::clear_has_subscriber() { + _has_bits_[0] &= ~0x00000010u; +} +inline void UpdateMemberStateNotification::clear_subscriber() { + if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear(); + clear_has_subscriber(); +} +inline const ::bgs::protocol::account::v1::Identity& UpdateMemberStateNotification::subscriber() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateMemberStateNotification.subscriber) + return subscriber_ != NULL ? *subscriber_ : *default_instance_->subscriber_; +} +inline ::bgs::protocol::account::v1::Identity* UpdateMemberStateNotification::mutable_subscriber() { + set_has_subscriber(); + if (subscriber_ == NULL) subscriber_ = new ::bgs::protocol::account::v1::Identity; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateMemberStateNotification.subscriber) + return subscriber_; +} +inline ::bgs::protocol::account::v1::Identity* UpdateMemberStateNotification::release_subscriber() { + clear_has_subscriber(); + ::bgs::protocol::account::v1::Identity* temp = subscriber_; + subscriber_ = NULL; + return temp; +} +inline void UpdateMemberStateNotification::set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber) { + delete subscriber_; + subscriber_ = subscriber; + if (subscriber) { + set_has_subscriber(); + } else { + clear_has_subscriber(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateMemberStateNotification.subscriber) +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace channel +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_channel_5fservice_2eproto__INCLUDED diff --git a/src/server/proto/Client/channel_types.pb.cc b/src/server/proto/Client/channel_types.pb.cc new file mode 100644 index 00000000000..b7f3bd56cc6 --- /dev/null +++ b/src/server/proto/Client/channel_types.pb.cc @@ -0,0 +1,3717 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: channel_types.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "channel_types.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { +namespace channel { +namespace v1 { + +namespace { + +const ::google::protobuf::Descriptor* ChannelId_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ChannelId_reflection_ = NULL; +const ::google::protobuf::Descriptor* Message_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Message_reflection_ = NULL; +const ::google::protobuf::Descriptor* ListChannelsOptions_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ListChannelsOptions_reflection_ = NULL; +const ::google::protobuf::Descriptor* ChannelDescription_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ChannelDescription_reflection_ = NULL; +const ::google::protobuf::Descriptor* ChannelInfo_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ChannelInfo_reflection_ = NULL; +const ::google::protobuf::Descriptor* ChannelState_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ChannelState_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* ChannelState_PrivacyLevel_descriptor_ = NULL; +const ::google::protobuf::Descriptor* MemberState_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + MemberState_reflection_ = NULL; +const ::google::protobuf::Descriptor* Member_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Member_reflection_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_channel_5ftypes_2eproto() { + protobuf_AddDesc_channel_5ftypes_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "channel_types.proto"); + GOOGLE_CHECK(file != NULL); + ChannelId_descriptor_ = file->message_type(0); + static const int ChannelId_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelId, type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelId, host_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelId, id_), + }; + ChannelId_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ChannelId_descriptor_, + ChannelId::default_instance_, + ChannelId_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelId, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelId, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ChannelId)); + Message_descriptor_ = file->message_type(1); + static const int Message_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Message, attribute_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Message, role_), + }; + Message_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Message_descriptor_, + Message::default_instance_, + Message_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Message, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Message, _unknown_fields_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Message, _extensions_), + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Message)); + ListChannelsOptions_descriptor_ = file->message_type(2); + static const int ListChannelsOptions_offsets_[8] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ListChannelsOptions, start_index_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ListChannelsOptions, max_results_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ListChannelsOptions, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ListChannelsOptions, program_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ListChannelsOptions, locale_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ListChannelsOptions, capacity_full_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ListChannelsOptions, attribute_filter_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ListChannelsOptions, channel_type_), + }; + ListChannelsOptions_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ListChannelsOptions_descriptor_, + ListChannelsOptions::default_instance_, + ListChannelsOptions_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ListChannelsOptions, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ListChannelsOptions, _unknown_fields_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ListChannelsOptions, _extensions_), + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ListChannelsOptions)); + ChannelDescription_descriptor_ = file->message_type(3); + static const int ChannelDescription_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelDescription, channel_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelDescription, current_members_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelDescription, state_), + }; + ChannelDescription_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ChannelDescription_descriptor_, + ChannelDescription::default_instance_, + ChannelDescription_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelDescription, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelDescription, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ChannelDescription)); + ChannelInfo_descriptor_ = file->message_type(4); + static const int ChannelInfo_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelInfo, description_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelInfo, member_), + }; + ChannelInfo_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ChannelInfo_descriptor_, + ChannelInfo::default_instance_, + ChannelInfo_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelInfo, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelInfo, _unknown_fields_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelInfo, _extensions_), + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ChannelInfo)); + ChannelState_descriptor_ = file->message_type(5); + static const int ChannelState_offsets_[14] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, max_members_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, min_members_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, attribute_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, invitation_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, max_invitations_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, reason_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, privacy_level_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, delegate_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, channel_type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, program_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, allow_offline_members_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, subscribe_to_presence_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, destroy_on_founder_leave_), + }; + ChannelState_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ChannelState_descriptor_, + ChannelState::default_instance_, + ChannelState_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, _unknown_fields_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, _extensions_), + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ChannelState)); + ChannelState_PrivacyLevel_descriptor_ = ChannelState_descriptor_->enum_type(0); + MemberState_descriptor_ = file->message_type(6); + static const int MemberState_offsets_[5] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberState, attribute_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberState, role_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberState, privileges_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberState, info_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberState, deprecated_hidden_), + }; + MemberState_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + MemberState_descriptor_, + MemberState::default_instance_, + MemberState_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberState, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberState, _unknown_fields_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberState, _extensions_), + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(MemberState)); + Member_descriptor_ = file->message_type(7); + static const int Member_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Member, identity_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Member, state_), + }; + Member_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Member_descriptor_, + Member::default_instance_, + Member_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Member, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Member, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Member)); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_channel_5ftypes_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ChannelId_descriptor_, &ChannelId::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Message_descriptor_, &Message::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ListChannelsOptions_descriptor_, &ListChannelsOptions::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ChannelDescription_descriptor_, &ChannelDescription::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ChannelInfo_descriptor_, &ChannelInfo::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ChannelState_descriptor_, &ChannelState::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + MemberState_descriptor_, &MemberState::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Member_descriptor_, &Member::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_channel_5ftypes_2eproto() { + delete ChannelId::default_instance_; + delete ChannelId_reflection_; + delete Message::default_instance_; + delete Message_reflection_; + delete ListChannelsOptions::default_instance_; + delete ListChannelsOptions_reflection_; + delete ChannelDescription::default_instance_; + delete ChannelDescription_reflection_; + delete ChannelInfo::default_instance_; + delete ChannelInfo_reflection_; + delete ChannelState::default_instance_; + delete ChannelState_reflection_; + delete ChannelState::_default_channel_type_; + delete MemberState::default_instance_; + delete MemberState_reflection_; + delete Member::default_instance_; + delete Member_reflection_; +} + +void protobuf_AddDesc_channel_5ftypes_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_invitation_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\023channel_types.proto\022\027bgs.protocol.chan" + "nel.v1\032\025attribute_types.proto\032\022entity_ty" + "pes.proto\032\026invitation_types.proto\032\017rpc_t" + "ypes.proto\"L\n\tChannelId\022\014\n\004type\030\001 \001(\r\022%\n" + "\004host\030\002 \001(\0132\027.bgs.protocol.ProcessId\022\n\n\002" + "id\030\003 \001(\007\"J\n\007Message\022*\n\tattribute\030\001 \003(\0132\027" + ".bgs.protocol.Attribute\022\014\n\004role\030\002 \001(\r*\005\010" + "d\020\220N\"\342\001\n\023ListChannelsOptions\022\026\n\013start_in" + "dex\030\001 \001(\r:\0010\022\027\n\013max_results\030\002 \001(\r:\00216\022\014\n" + "\004name\030\003 \001(\t\022\017\n\007program\030\004 \001(\007\022\016\n\006locale\030\005" + " \001(\007\022\025\n\rcapacity_full\030\006 \001(\r\0227\n\020attribute" + "_filter\030\007 \002(\0132\035.bgs.protocol.AttributeFi" + "lter\022\024\n\014channel_type\030\010 \001(\t*\005\010d\020\220N\"\217\001\n\022Ch" + "annelDescription\022*\n\nchannel_id\030\001 \002(\0132\026.b" + "gs.protocol.EntityId\022\027\n\017current_members\030" + "\002 \001(\r\0224\n\005state\030\003 \001(\0132%.bgs.protocol.chan" + "nel.v1.ChannelState\"\207\001\n\013ChannelInfo\022@\n\013d" + "escription\030\001 \002(\0132+.bgs.protocol.channel." + "v1.ChannelDescription\022/\n\006member\030\002 \003(\0132\037." + "bgs.protocol.channel.v1.Member*\005\010d\020\220N\"\201\005" + "\n\014ChannelState\022\023\n\013max_members\030\001 \001(\r\022\023\n\013m" + "in_members\030\002 \001(\r\022*\n\tattribute\030\003 \003(\0132\027.bg" + "s.protocol.Attribute\022,\n\ninvitation\030\004 \003(\013" + "2\030.bgs.protocol.Invitation\022\027\n\017max_invita" + "tions\030\005 \001(\r\022\016\n\006reason\030\006 \001(\r\022]\n\rprivacy_l" + "evel\030\007 \001(\01622.bgs.protocol.channel.v1.Cha" + "nnelState.PrivacyLevel:\022PRIVACY_LEVEL_OP" + "EN\022\014\n\004name\030\010 \001(\t\022\025\n\rdelegate_name\030\t \001(\t\022" + "\035\n\014channel_type\030\n \001(\t:\007default\022\022\n\007progra" + "m\030\013 \001(\007:\0010\022$\n\025allow_offline_members\030\014 \001(" + "\010:\005false\022#\n\025subscribe_to_presence\030\r \001(\010:" + "\004true\022\'\n\030destroy_on_founder_leave\030\016 \001(\010:" + "\005false\"\221\001\n\014PrivacyLevel\022\026\n\022PRIVACY_LEVEL" + "_OPEN\020\001\022,\n(PRIVACY_LEVEL_OPEN_INVITATION" + "_AND_FRIEND\020\002\022!\n\035PRIVACY_LEVEL_OPEN_INVI" + "TATION\020\003\022\030\n\024PRIVACY_LEVEL_CLOSED\020\004*\005\010d\020\220" + "N\"\270\001\n\013MemberState\022*\n\tattribute\030\001 \003(\0132\027.b" + "gs.protocol.Attribute\022\020\n\004role\030\002 \003(\rB\002\020\001\022" + "\025\n\nprivileges\030\003 \001(\004:\0010\022\'\n\004info\030\004 \001(\0132\031.b" + "gs.protocol.AccountInfo\022$\n\021DEPRECATED_hi" + "dden\030\005 \001(\010:\005falseB\002\030\001*\005\010d\020\220N\"g\n\006Member\022(" + "\n\010identity\030\001 \002(\0132\026.bgs.protocol.Identity" + "\0223\n\005state\030\002 \002(\0132$.bgs.protocol.channel.v" + "1.MemberStateB\002H\001", 1737); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "channel_types.proto", &protobuf_RegisterTypes); + ChannelId::default_instance_ = new ChannelId(); + Message::default_instance_ = new Message(); + ListChannelsOptions::default_instance_ = new ListChannelsOptions(); + ChannelDescription::default_instance_ = new ChannelDescription(); + ChannelInfo::default_instance_ = new ChannelInfo(); + ChannelState::_default_channel_type_ = + new ::std::string("default", 7); + ChannelState::default_instance_ = new ChannelState(); + MemberState::default_instance_ = new MemberState(); + Member::default_instance_ = new Member(); + ChannelId::default_instance_->InitAsDefaultInstance(); + Message::default_instance_->InitAsDefaultInstance(); + ListChannelsOptions::default_instance_->InitAsDefaultInstance(); + ChannelDescription::default_instance_->InitAsDefaultInstance(); + ChannelInfo::default_instance_->InitAsDefaultInstance(); + ChannelState::default_instance_->InitAsDefaultInstance(); + MemberState::default_instance_->InitAsDefaultInstance(); + Member::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_channel_5ftypes_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_channel_5ftypes_2eproto { + StaticDescriptorInitializer_channel_5ftypes_2eproto() { + protobuf_AddDesc_channel_5ftypes_2eproto(); + } +} static_descriptor_initializer_channel_5ftypes_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int ChannelId::kTypeFieldNumber; +const int ChannelId::kHostFieldNumber; +const int ChannelId::kIdFieldNumber; +#endif // !_MSC_VER + +ChannelId::ChannelId() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.ChannelId) +} + +void ChannelId::InitAsDefaultInstance() { + host_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance()); +} + +ChannelId::ChannelId(const ChannelId& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.ChannelId) +} + +void ChannelId::SharedCtor() { + _cached_size_ = 0; + type_ = 0u; + host_ = NULL; + id_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ChannelId::~ChannelId() { + // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.ChannelId) + SharedDtor(); +} + +void ChannelId::SharedDtor() { + if (this != default_instance_) { + delete host_; + } +} + +void ChannelId::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ChannelId::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ChannelId_descriptor_; +} + +const ChannelId& ChannelId::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_channel_5ftypes_2eproto(); + return *default_instance_; +} + +ChannelId* ChannelId::default_instance_ = NULL; + +ChannelId* ChannelId::New() const { + return new ChannelId; +} + +void ChannelId::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(type_, id_); + if (has_host()) { + if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear(); + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ChannelId::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.ChannelId) + 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 type = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &type_))); + set_has_type(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_host; + break; + } + + // optional .bgs.protocol.ProcessId host = 2; + case 2: { + if (tag == 18) { + parse_host: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_host())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(29)) goto parse_id; + break; + } + + // optional fixed32 id = 3; + case 3: { + if (tag == 29) { + parse_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &id_))); + set_has_id(); + } 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:bgs.protocol.channel.v1.ChannelId) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.ChannelId) + return false; +#undef DO_ +} + +void ChannelId::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.ChannelId) + // optional uint32 type = 1; + if (has_type()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->type(), output); + } + + // optional .bgs.protocol.ProcessId host = 2; + if (has_host()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->host(), output); + } + + // optional fixed32 id = 3; + if (has_id()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.ChannelId) +} + +::google::protobuf::uint8* ChannelId::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.ChannelId) + // optional uint32 type = 1; + if (has_type()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->type(), target); + } + + // optional .bgs.protocol.ProcessId host = 2; + if (has_host()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->host(), target); + } + + // optional fixed32 id = 3; + if (has_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.ChannelId) + return target; +} + +int ChannelId::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional uint32 type = 1; + if (has_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->type()); + } + + // optional .bgs.protocol.ProcessId host = 2; + if (has_host()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->host()); + } + + // optional fixed32 id = 3; + if (has_id()) { + 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 ChannelId::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ChannelId* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ChannelId::MergeFrom(const ChannelId& 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_host()) { + mutable_host()->::bgs::protocol::ProcessId::MergeFrom(from.host()); + } + if (from.has_id()) { + set_id(from.id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ChannelId::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ChannelId::CopyFrom(const ChannelId& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ChannelId::IsInitialized() const { + + if (has_host()) { + if (!this->host().IsInitialized()) return false; + } + return true; +} + +void ChannelId::Swap(ChannelId* other) { + if (other != this) { + std::swap(type_, other->type_); + std::swap(host_, other->host_); + std::swap(id_, other->id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata ChannelId::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ChannelId_descriptor_; + metadata.reflection = ChannelId_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int Message::kAttributeFieldNumber; +const int Message::kRoleFieldNumber; +#endif // !_MSC_VER + +Message::Message() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.Message) +} + +void Message::InitAsDefaultInstance() { +} + +Message::Message(const Message& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.Message) +} + +void Message::SharedCtor() { + _cached_size_ = 0; + role_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Message::~Message() { + // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.Message) + SharedDtor(); +} + +void Message::SharedDtor() { + if (this != default_instance_) { + } +} + +void Message::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Message::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Message_descriptor_; +} + +const Message& Message::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_channel_5ftypes_2eproto(); + return *default_instance_; +} + +Message* Message::default_instance_ = NULL; + +Message* Message::New() const { + return new Message; +} + +void Message::Clear() { + _extensions_.Clear(); + role_ = 0u; + attribute_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Message::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.Message) + 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 .bgs.protocol.Attribute attribute = 1; + case 1: { + if (tag == 10) { + parse_attribute: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_attribute())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_attribute; + if (input->ExpectTag(16)) goto parse_role; + break; + } + + // optional uint32 role = 2; + case 2: { + if (tag == 16) { + parse_role: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &role_))); + set_has_role(); + } 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; + } + if ((800u <= tag && tag < 80000u)) { + DO_(_extensions_.ParseField(tag, input, default_instance_, + mutable_unknown_fields())); + continue; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.Message) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.Message) + return false; +#undef DO_ +} + +void Message::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.Message) + // repeated .bgs.protocol.Attribute attribute = 1; + for (int i = 0; i < this->attribute_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->attribute(i), output); + } + + // optional uint32 role = 2; + if (has_role()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->role(), output); + } + + // Extension range [100, 10000) + _extensions_.SerializeWithCachedSizes( + 100, 10000, output); + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.Message) +} + +::google::protobuf::uint8* Message::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.Message) + // repeated .bgs.protocol.Attribute attribute = 1; + for (int i = 0; i < this->attribute_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->attribute(i), target); + } + + // optional uint32 role = 2; + if (has_role()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->role(), target); + } + + // Extension range [100, 10000) + target = _extensions_.SerializeWithCachedSizesToArray( + 100, 10000, target); + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.Message) + return target; +} + +int Message::ByteSize() const { + int total_size = 0; + + if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) { + // optional uint32 role = 2; + if (has_role()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->role()); + } + + } + // repeated .bgs.protocol.Attribute attribute = 1; + total_size += 1 * this->attribute_size(); + for (int i = 0; i < this->attribute_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->attribute(i)); + } + + total_size += _extensions_.ByteSize(); + + 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 Message::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Message* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Message::MergeFrom(const Message& from) { + GOOGLE_CHECK_NE(&from, this); + attribute_.MergeFrom(from.attribute_); + if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) { + if (from.has_role()) { + set_role(from.role()); + } + } + _extensions_.MergeFrom(from._extensions_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Message::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Message::CopyFrom(const Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false; + + if (!_extensions_.IsInitialized()) return false; return true; +} + +void Message::Swap(Message* other) { + if (other != this) { + attribute_.Swap(&other->attribute_); + std::swap(role_, other->role_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + _extensions_.Swap(&other->_extensions_); + } +} + +::google::protobuf::Metadata Message::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Message_descriptor_; + metadata.reflection = Message_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ListChannelsOptions::kStartIndexFieldNumber; +const int ListChannelsOptions::kMaxResultsFieldNumber; +const int ListChannelsOptions::kNameFieldNumber; +const int ListChannelsOptions::kProgramFieldNumber; +const int ListChannelsOptions::kLocaleFieldNumber; +const int ListChannelsOptions::kCapacityFullFieldNumber; +const int ListChannelsOptions::kAttributeFilterFieldNumber; +const int ListChannelsOptions::kChannelTypeFieldNumber; +#endif // !_MSC_VER + +ListChannelsOptions::ListChannelsOptions() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.ListChannelsOptions) +} + +void ListChannelsOptions::InitAsDefaultInstance() { + attribute_filter_ = const_cast< ::bgs::protocol::AttributeFilter*>(&::bgs::protocol::AttributeFilter::default_instance()); +} + +ListChannelsOptions::ListChannelsOptions(const ListChannelsOptions& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.ListChannelsOptions) +} + +void ListChannelsOptions::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + start_index_ = 0u; + max_results_ = 16u; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + program_ = 0u; + locale_ = 0u; + capacity_full_ = 0u; + attribute_filter_ = NULL; + channel_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ListChannelsOptions::~ListChannelsOptions() { + // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.ListChannelsOptions) + SharedDtor(); +} + +void ListChannelsOptions::SharedDtor() { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete name_; + } + if (channel_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete channel_type_; + } + if (this != default_instance_) { + delete attribute_filter_; + } +} + +void ListChannelsOptions::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ListChannelsOptions::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ListChannelsOptions_descriptor_; +} + +const ListChannelsOptions& ListChannelsOptions::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_channel_5ftypes_2eproto(); + return *default_instance_; +} + +ListChannelsOptions* ListChannelsOptions::default_instance_ = NULL; + +ListChannelsOptions* ListChannelsOptions::New() const { + return new ListChannelsOptions; +} + +void ListChannelsOptions::Clear() { + _extensions_.Clear(); +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(program_, locale_); + start_index_ = 0u; + max_results_ = 16u; + if (has_name()) { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_->clear(); + } + } + capacity_full_ = 0u; + if (has_attribute_filter()) { + if (attribute_filter_ != NULL) attribute_filter_->::bgs::protocol::AttributeFilter::Clear(); + } + if (has_channel_type()) { + if (channel_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + channel_type_->clear(); + } + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ListChannelsOptions::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.ListChannelsOptions) + 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 start_index = 1 [default = 0]; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &start_index_))); + set_has_start_index(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_max_results; + break; + } + + // optional uint32 max_results = 2 [default = 16]; + case 2: { + if (tag == 16) { + parse_max_results: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &max_results_))); + set_has_max_results(); + } 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(37)) goto parse_program; + break; + } + + // optional fixed32 program = 4; + case 4: { + if (tag == 37) { + parse_program: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &program_))); + set_has_program(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(45)) goto parse_locale; + break; + } + + // optional fixed32 locale = 5; + case 5: { + if (tag == 45) { + parse_locale: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &locale_))); + set_has_locale(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_capacity_full; + break; + } + + // optional uint32 capacity_full = 6; + case 6: { + if (tag == 48) { + parse_capacity_full: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &capacity_full_))); + set_has_capacity_full(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(58)) goto parse_attribute_filter; + break; + } + + // required .bgs.protocol.AttributeFilter attribute_filter = 7; + case 7: { + if (tag == 58) { + parse_attribute_filter: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_attribute_filter())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(66)) goto parse_channel_type; + break; + } + + // optional string channel_type = 8; + case 8: { + if (tag == 66) { + parse_channel_type: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_channel_type())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->channel_type().data(), this->channel_type().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "channel_type"); + } 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; + } + if ((800u <= tag && tag < 80000u)) { + DO_(_extensions_.ParseField(tag, input, default_instance_, + mutable_unknown_fields())); + continue; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.ListChannelsOptions) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.ListChannelsOptions) + return false; +#undef DO_ +} + +void ListChannelsOptions::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.ListChannelsOptions) + // optional uint32 start_index = 1 [default = 0]; + if (has_start_index()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->start_index(), output); + } + + // optional uint32 max_results = 2 [default = 16]; + if (has_max_results()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->max_results(), 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 fixed32 program = 4; + if (has_program()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->program(), output); + } + + // optional fixed32 locale = 5; + if (has_locale()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->locale(), output); + } + + // optional uint32 capacity_full = 6; + if (has_capacity_full()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->capacity_full(), output); + } + + // required .bgs.protocol.AttributeFilter attribute_filter = 7; + if (has_attribute_filter()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 7, this->attribute_filter(), output); + } + + // optional string channel_type = 8; + if (has_channel_type()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->channel_type().data(), this->channel_type().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "channel_type"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 8, this->channel_type(), output); + } + + // Extension range [100, 10000) + _extensions_.SerializeWithCachedSizes( + 100, 10000, output); + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.ListChannelsOptions) +} + +::google::protobuf::uint8* ListChannelsOptions::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.ListChannelsOptions) + // optional uint32 start_index = 1 [default = 0]; + if (has_start_index()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->start_index(), target); + } + + // optional uint32 max_results = 2 [default = 16]; + if (has_max_results()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->max_results(), 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 fixed32 program = 4; + if (has_program()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->program(), target); + } + + // optional fixed32 locale = 5; + if (has_locale()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->locale(), target); + } + + // optional uint32 capacity_full = 6; + if (has_capacity_full()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->capacity_full(), target); + } + + // required .bgs.protocol.AttributeFilter attribute_filter = 7; + if (has_attribute_filter()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 7, this->attribute_filter(), target); + } + + // optional string channel_type = 8; + if (has_channel_type()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->channel_type().data(), this->channel_type().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "channel_type"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 8, this->channel_type(), target); + } + + // Extension range [100, 10000) + target = _extensions_.SerializeWithCachedSizesToArray( + 100, 10000, target); + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.ListChannelsOptions) + return target; +} + +int ListChannelsOptions::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional uint32 start_index = 1 [default = 0]; + if (has_start_index()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->start_index()); + } + + // optional uint32 max_results = 2 [default = 16]; + if (has_max_results()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->max_results()); + } + + // optional string name = 3; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // optional fixed32 program = 4; + if (has_program()) { + total_size += 1 + 4; + } + + // optional fixed32 locale = 5; + if (has_locale()) { + total_size += 1 + 4; + } + + // optional uint32 capacity_full = 6; + if (has_capacity_full()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->capacity_full()); + } + + // required .bgs.protocol.AttributeFilter attribute_filter = 7; + if (has_attribute_filter()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->attribute_filter()); + } + + // optional string channel_type = 8; + if (has_channel_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->channel_type()); + } + + } + total_size += _extensions_.ByteSize(); + + 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 ListChannelsOptions::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ListChannelsOptions* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ListChannelsOptions::MergeFrom(const ListChannelsOptions& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_start_index()) { + set_start_index(from.start_index()); + } + if (from.has_max_results()) { + set_max_results(from.max_results()); + } + if (from.has_name()) { + set_name(from.name()); + } + if (from.has_program()) { + set_program(from.program()); + } + if (from.has_locale()) { + set_locale(from.locale()); + } + if (from.has_capacity_full()) { + set_capacity_full(from.capacity_full()); + } + if (from.has_attribute_filter()) { + mutable_attribute_filter()->::bgs::protocol::AttributeFilter::MergeFrom(from.attribute_filter()); + } + if (from.has_channel_type()) { + set_channel_type(from.channel_type()); + } + } + _extensions_.MergeFrom(from._extensions_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ListChannelsOptions::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ListChannelsOptions::CopyFrom(const ListChannelsOptions& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ListChannelsOptions::IsInitialized() const { + if ((_has_bits_[0] & 0x00000040) != 0x00000040) return false; + + if (has_attribute_filter()) { + if (!this->attribute_filter().IsInitialized()) return false; + } + + if (!_extensions_.IsInitialized()) return false; return true; +} + +void ListChannelsOptions::Swap(ListChannelsOptions* other) { + if (other != this) { + std::swap(start_index_, other->start_index_); + std::swap(max_results_, other->max_results_); + std::swap(name_, other->name_); + std::swap(program_, other->program_); + std::swap(locale_, other->locale_); + std::swap(capacity_full_, other->capacity_full_); + std::swap(attribute_filter_, other->attribute_filter_); + std::swap(channel_type_, other->channel_type_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + _extensions_.Swap(&other->_extensions_); + } +} + +::google::protobuf::Metadata ListChannelsOptions::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ListChannelsOptions_descriptor_; + metadata.reflection = ListChannelsOptions_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ChannelDescription::kChannelIdFieldNumber; +const int ChannelDescription::kCurrentMembersFieldNumber; +const int ChannelDescription::kStateFieldNumber; +#endif // !_MSC_VER + +ChannelDescription::ChannelDescription() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.ChannelDescription) +} + +void ChannelDescription::InitAsDefaultInstance() { + channel_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + state_ = const_cast< ::bgs::protocol::channel::v1::ChannelState*>(&::bgs::protocol::channel::v1::ChannelState::default_instance()); +} + +ChannelDescription::ChannelDescription(const ChannelDescription& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.ChannelDescription) +} + +void ChannelDescription::SharedCtor() { + _cached_size_ = 0; + channel_id_ = NULL; + current_members_ = 0u; + state_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ChannelDescription::~ChannelDescription() { + // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.ChannelDescription) + SharedDtor(); +} + +void ChannelDescription::SharedDtor() { + if (this != default_instance_) { + delete channel_id_; + delete state_; + } +} + +void ChannelDescription::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ChannelDescription::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ChannelDescription_descriptor_; +} + +const ChannelDescription& ChannelDescription::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_channel_5ftypes_2eproto(); + return *default_instance_; +} + +ChannelDescription* ChannelDescription::default_instance_ = NULL; + +ChannelDescription* ChannelDescription::New() const { + return new ChannelDescription; +} + +void ChannelDescription::Clear() { + if (_has_bits_[0 / 32] & 7) { + if (has_channel_id()) { + if (channel_id_ != NULL) channel_id_->::bgs::protocol::EntityId::Clear(); + } + current_members_ = 0u; + if (has_state()) { + if (state_ != NULL) state_->::bgs::protocol::channel::v1::ChannelState::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ChannelDescription::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.ChannelDescription) + 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)) { + // required .bgs.protocol.EntityId channel_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_channel_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_current_members; + break; + } + + // optional uint32 current_members = 2; + case 2: { + if (tag == 16) { + parse_current_members: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, ¤t_members_))); + set_has_current_members(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_state; + break; + } + + // optional .bgs.protocol.channel.v1.ChannelState state = 3; + case 3: { + if (tag == 26) { + parse_state: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_state())); + } 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:bgs.protocol.channel.v1.ChannelDescription) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.ChannelDescription) + return false; +#undef DO_ +} + +void ChannelDescription::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.ChannelDescription) + // required .bgs.protocol.EntityId channel_id = 1; + if (has_channel_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->channel_id(), output); + } + + // optional uint32 current_members = 2; + if (has_current_members()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->current_members(), output); + } + + // optional .bgs.protocol.channel.v1.ChannelState state = 3; + if (has_state()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->state(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.ChannelDescription) +} + +::google::protobuf::uint8* ChannelDescription::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.ChannelDescription) + // required .bgs.protocol.EntityId channel_id = 1; + if (has_channel_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->channel_id(), target); + } + + // optional uint32 current_members = 2; + if (has_current_members()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->current_members(), target); + } + + // optional .bgs.protocol.channel.v1.ChannelState state = 3; + if (has_state()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->state(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.ChannelDescription) + return target; +} + +int ChannelDescription::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.EntityId channel_id = 1; + if (has_channel_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->channel_id()); + } + + // optional uint32 current_members = 2; + if (has_current_members()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->current_members()); + } + + // optional .bgs.protocol.channel.v1.ChannelState state = 3; + if (has_state()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->state()); + } + + } + 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 ChannelDescription::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ChannelDescription* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ChannelDescription::MergeFrom(const ChannelDescription& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_channel_id()) { + mutable_channel_id()->::bgs::protocol::EntityId::MergeFrom(from.channel_id()); + } + if (from.has_current_members()) { + set_current_members(from.current_members()); + } + if (from.has_state()) { + mutable_state()->::bgs::protocol::channel::v1::ChannelState::MergeFrom(from.state()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ChannelDescription::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ChannelDescription::CopyFrom(const ChannelDescription& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ChannelDescription::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_channel_id()) { + if (!this->channel_id().IsInitialized()) return false; + } + if (has_state()) { + if (!this->state().IsInitialized()) return false; + } + return true; +} + +void ChannelDescription::Swap(ChannelDescription* other) { + if (other != this) { + std::swap(channel_id_, other->channel_id_); + std::swap(current_members_, other->current_members_); + std::swap(state_, other->state_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata ChannelDescription::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ChannelDescription_descriptor_; + metadata.reflection = ChannelDescription_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ChannelInfo::kDescriptionFieldNumber; +const int ChannelInfo::kMemberFieldNumber; +#endif // !_MSC_VER + +ChannelInfo::ChannelInfo() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.ChannelInfo) +} + +void ChannelInfo::InitAsDefaultInstance() { + description_ = const_cast< ::bgs::protocol::channel::v1::ChannelDescription*>(&::bgs::protocol::channel::v1::ChannelDescription::default_instance()); +} + +ChannelInfo::ChannelInfo(const ChannelInfo& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.ChannelInfo) +} + +void ChannelInfo::SharedCtor() { + _cached_size_ = 0; + description_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ChannelInfo::~ChannelInfo() { + // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.ChannelInfo) + SharedDtor(); +} + +void ChannelInfo::SharedDtor() { + if (this != default_instance_) { + delete description_; + } +} + +void ChannelInfo::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ChannelInfo::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ChannelInfo_descriptor_; +} + +const ChannelInfo& ChannelInfo::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_channel_5ftypes_2eproto(); + return *default_instance_; +} + +ChannelInfo* ChannelInfo::default_instance_ = NULL; + +ChannelInfo* ChannelInfo::New() const { + return new ChannelInfo; +} + +void ChannelInfo::Clear() { + _extensions_.Clear(); + if (has_description()) { + if (description_ != NULL) description_->::bgs::protocol::channel::v1::ChannelDescription::Clear(); + } + member_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ChannelInfo::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.ChannelInfo) + 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)) { + // required .bgs.protocol.channel.v1.ChannelDescription description = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_description())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_member; + break; + } + + // repeated .bgs.protocol.channel.v1.Member member = 2; + case 2: { + if (tag == 18) { + parse_member: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_member())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_member; + 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; + } + if ((800u <= tag && tag < 80000u)) { + DO_(_extensions_.ParseField(tag, input, default_instance_, + mutable_unknown_fields())); + continue; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.ChannelInfo) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.ChannelInfo) + return false; +#undef DO_ +} + +void ChannelInfo::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.ChannelInfo) + // required .bgs.protocol.channel.v1.ChannelDescription description = 1; + if (has_description()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->description(), output); + } + + // repeated .bgs.protocol.channel.v1.Member member = 2; + for (int i = 0; i < this->member_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->member(i), output); + } + + // Extension range [100, 10000) + _extensions_.SerializeWithCachedSizes( + 100, 10000, output); + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.ChannelInfo) +} + +::google::protobuf::uint8* ChannelInfo::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.ChannelInfo) + // required .bgs.protocol.channel.v1.ChannelDescription description = 1; + if (has_description()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->description(), target); + } + + // repeated .bgs.protocol.channel.v1.Member member = 2; + for (int i = 0; i < this->member_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->member(i), target); + } + + // Extension range [100, 10000) + target = _extensions_.SerializeWithCachedSizesToArray( + 100, 10000, target); + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.ChannelInfo) + return target; +} + +int ChannelInfo::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.channel.v1.ChannelDescription description = 1; + if (has_description()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->description()); + } + + } + // repeated .bgs.protocol.channel.v1.Member member = 2; + total_size += 1 * this->member_size(); + for (int i = 0; i < this->member_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->member(i)); + } + + total_size += _extensions_.ByteSize(); + + 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 ChannelInfo::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ChannelInfo* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ChannelInfo::MergeFrom(const ChannelInfo& from) { + GOOGLE_CHECK_NE(&from, this); + member_.MergeFrom(from.member_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_description()) { + mutable_description()->::bgs::protocol::channel::v1::ChannelDescription::MergeFrom(from.description()); + } + } + _extensions_.MergeFrom(from._extensions_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ChannelInfo::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ChannelInfo::CopyFrom(const ChannelInfo& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ChannelInfo::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_description()) { + if (!this->description().IsInitialized()) return false; + } + if (!::google::protobuf::internal::AllAreInitialized(this->member())) return false; + + if (!_extensions_.IsInitialized()) return false; return true; +} + +void ChannelInfo::Swap(ChannelInfo* other) { + if (other != this) { + std::swap(description_, other->description_); + member_.Swap(&other->member_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + _extensions_.Swap(&other->_extensions_); + } +} + +::google::protobuf::Metadata ChannelInfo::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ChannelInfo_descriptor_; + metadata.reflection = ChannelInfo_reflection_; + return metadata; +} + + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* ChannelState_PrivacyLevel_descriptor() { + protobuf_AssignDescriptorsOnce(); + return ChannelState_PrivacyLevel_descriptor_; +} +bool ChannelState_PrivacyLevel_IsValid(int value) { + switch(value) { + case 1: + case 2: + case 3: + case 4: + return true; + default: + return false; + } +} + +#ifndef _MSC_VER +const ChannelState_PrivacyLevel ChannelState::PRIVACY_LEVEL_OPEN; +const ChannelState_PrivacyLevel ChannelState::PRIVACY_LEVEL_OPEN_INVITATION_AND_FRIEND; +const ChannelState_PrivacyLevel ChannelState::PRIVACY_LEVEL_OPEN_INVITATION; +const ChannelState_PrivacyLevel ChannelState::PRIVACY_LEVEL_CLOSED; +const ChannelState_PrivacyLevel ChannelState::PrivacyLevel_MIN; +const ChannelState_PrivacyLevel ChannelState::PrivacyLevel_MAX; +const int ChannelState::PrivacyLevel_ARRAYSIZE; +#endif // _MSC_VER +::std::string* ChannelState::_default_channel_type_ = NULL; +#ifndef _MSC_VER +const int ChannelState::kMaxMembersFieldNumber; +const int ChannelState::kMinMembersFieldNumber; +const int ChannelState::kAttributeFieldNumber; +const int ChannelState::kInvitationFieldNumber; +const int ChannelState::kMaxInvitationsFieldNumber; +const int ChannelState::kReasonFieldNumber; +const int ChannelState::kPrivacyLevelFieldNumber; +const int ChannelState::kNameFieldNumber; +const int ChannelState::kDelegateNameFieldNumber; +const int ChannelState::kChannelTypeFieldNumber; +const int ChannelState::kProgramFieldNumber; +const int ChannelState::kAllowOfflineMembersFieldNumber; +const int ChannelState::kSubscribeToPresenceFieldNumber; +const int ChannelState::kDestroyOnFounderLeaveFieldNumber; +#endif // !_MSC_VER + +ChannelState::ChannelState() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.ChannelState) +} + +void ChannelState::InitAsDefaultInstance() { +} + +ChannelState::ChannelState(const ChannelState& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.ChannelState) +} + +void ChannelState::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + max_members_ = 0u; + min_members_ = 0u; + max_invitations_ = 0u; + reason_ = 0u; + privacy_level_ = 1; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + delegate_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + channel_type_ = const_cast< ::std::string*>(_default_channel_type_); + program_ = 0u; + allow_offline_members_ = false; + subscribe_to_presence_ = true; + destroy_on_founder_leave_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ChannelState::~ChannelState() { + // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.ChannelState) + SharedDtor(); +} + +void ChannelState::SharedDtor() { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete name_; + } + if (delegate_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete delegate_name_; + } + if (channel_type_ != _default_channel_type_) { + delete channel_type_; + } + if (this != default_instance_) { + } +} + +void ChannelState::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ChannelState::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ChannelState_descriptor_; +} + +const ChannelState& ChannelState::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_channel_5ftypes_2eproto(); + return *default_instance_; +} + +ChannelState* ChannelState::default_instance_ = NULL; + +ChannelState* ChannelState::New() const { + return new ChannelState; +} + +void ChannelState::Clear() { + _extensions_.Clear(); +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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] & 243) { + ZR_(max_members_, min_members_); + ZR_(max_invitations_, reason_); + privacy_level_ = 1; + if (has_name()) { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_->clear(); + } + } + } + if (_has_bits_[8 / 32] & 16128) { + if (has_delegate_name()) { + if (delegate_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delegate_name_->clear(); + } + } + if (has_channel_type()) { + if (channel_type_ != _default_channel_type_) { + channel_type_->assign(*_default_channel_type_); + } + } + program_ = 0u; + allow_offline_members_ = false; + subscribe_to_presence_ = true; + destroy_on_founder_leave_ = false; + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + attribute_.Clear(); + invitation_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ChannelState::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.ChannelState) + 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 max_members = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &max_members_))); + set_has_max_members(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_min_members; + break; + } + + // optional uint32 min_members = 2; + case 2: { + if (tag == 16) { + parse_min_members: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &min_members_))); + set_has_min_members(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_attribute; + break; + } + + // repeated .bgs.protocol.Attribute attribute = 3; + case 3: { + if (tag == 26) { + parse_attribute: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_attribute())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_attribute; + if (input->ExpectTag(34)) goto parse_invitation; + break; + } + + // repeated .bgs.protocol.Invitation invitation = 4; + case 4: { + if (tag == 34) { + parse_invitation: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_invitation())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_invitation; + if (input->ExpectTag(40)) goto parse_max_invitations; + break; + } + + // optional uint32 max_invitations = 5; + case 5: { + if (tag == 40) { + parse_max_invitations: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &max_invitations_))); + set_has_max_invitations(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_reason; + break; + } + + // optional uint32 reason = 6; + case 6: { + if (tag == 48) { + parse_reason: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &reason_))); + set_has_reason(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(56)) goto parse_privacy_level; + break; + } + + // optional .bgs.protocol.channel.v1.ChannelState.PrivacyLevel privacy_level = 7 [default = PRIVACY_LEVEL_OPEN]; + case 7: { + if (tag == 56) { + parse_privacy_level: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::bgs::protocol::channel::v1::ChannelState_PrivacyLevel_IsValid(value)) { + set_privacy_level(static_cast< ::bgs::protocol::channel::v1::ChannelState_PrivacyLevel >(value)); + } else { + mutable_unknown_fields()->AddVarint(7, value); + } + } else { + goto handle_unusual; + } + if (input->ExpectTag(66)) goto parse_name; + break; + } + + // optional string name = 8; + case 8: { + if (tag == 66) { + 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(74)) goto parse_delegate_name; + break; + } + + // optional string delegate_name = 9; + case 9: { + if (tag == 74) { + parse_delegate_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_delegate_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->delegate_name().data(), this->delegate_name().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "delegate_name"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(82)) goto parse_channel_type; + break; + } + + // optional string channel_type = 10 [default = "default"]; + case 10: { + if (tag == 82) { + parse_channel_type: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_channel_type())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->channel_type().data(), this->channel_type().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "channel_type"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(93)) goto parse_program; + break; + } + + // optional fixed32 program = 11 [default = 0]; + case 11: { + if (tag == 93) { + parse_program: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &program_))); + set_has_program(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(96)) goto parse_allow_offline_members; + break; + } + + // optional bool allow_offline_members = 12 [default = false]; + case 12: { + if (tag == 96) { + parse_allow_offline_members: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &allow_offline_members_))); + set_has_allow_offline_members(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(104)) goto parse_subscribe_to_presence; + break; + } + + // optional bool subscribe_to_presence = 13 [default = true]; + case 13: { + if (tag == 104) { + parse_subscribe_to_presence: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &subscribe_to_presence_))); + set_has_subscribe_to_presence(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(112)) goto parse_destroy_on_founder_leave; + break; + } + + // optional bool destroy_on_founder_leave = 14 [default = false]; + case 14: { + if (tag == 112) { + parse_destroy_on_founder_leave: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &destroy_on_founder_leave_))); + set_has_destroy_on_founder_leave(); + } 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; + } + if ((800u <= tag && tag < 80000u)) { + DO_(_extensions_.ParseField(tag, input, default_instance_, + mutable_unknown_fields())); + continue; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.ChannelState) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.ChannelState) + return false; +#undef DO_ +} + +void ChannelState::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.ChannelState) + // optional uint32 max_members = 1; + if (has_max_members()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->max_members(), output); + } + + // optional uint32 min_members = 2; + if (has_min_members()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->min_members(), output); + } + + // repeated .bgs.protocol.Attribute attribute = 3; + for (int i = 0; i < this->attribute_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->attribute(i), output); + } + + // repeated .bgs.protocol.Invitation invitation = 4; + for (int i = 0; i < this->invitation_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->invitation(i), output); + } + + // optional uint32 max_invitations = 5; + if (has_max_invitations()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->max_invitations(), output); + } + + // optional uint32 reason = 6; + if (has_reason()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->reason(), output); + } + + // optional .bgs.protocol.channel.v1.ChannelState.PrivacyLevel privacy_level = 7 [default = PRIVACY_LEVEL_OPEN]; + if (has_privacy_level()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 7, this->privacy_level(), output); + } + + // optional string name = 8; + 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( + 8, this->name(), output); + } + + // optional string delegate_name = 9; + if (has_delegate_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->delegate_name().data(), this->delegate_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "delegate_name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 9, this->delegate_name(), output); + } + + // optional string channel_type = 10 [default = "default"]; + if (has_channel_type()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->channel_type().data(), this->channel_type().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "channel_type"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 10, this->channel_type(), output); + } + + // optional fixed32 program = 11 [default = 0]; + if (has_program()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(11, this->program(), output); + } + + // optional bool allow_offline_members = 12 [default = false]; + if (has_allow_offline_members()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(12, this->allow_offline_members(), output); + } + + // optional bool subscribe_to_presence = 13 [default = true]; + if (has_subscribe_to_presence()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(13, this->subscribe_to_presence(), output); + } + + // optional bool destroy_on_founder_leave = 14 [default = false]; + if (has_destroy_on_founder_leave()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(14, this->destroy_on_founder_leave(), output); + } + + // Extension range [100, 10000) + _extensions_.SerializeWithCachedSizes( + 100, 10000, output); + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.ChannelState) +} + +::google::protobuf::uint8* ChannelState::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.ChannelState) + // optional uint32 max_members = 1; + if (has_max_members()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->max_members(), target); + } + + // optional uint32 min_members = 2; + if (has_min_members()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->min_members(), target); + } + + // repeated .bgs.protocol.Attribute attribute = 3; + for (int i = 0; i < this->attribute_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->attribute(i), target); + } + + // repeated .bgs.protocol.Invitation invitation = 4; + for (int i = 0; i < this->invitation_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->invitation(i), target); + } + + // optional uint32 max_invitations = 5; + if (has_max_invitations()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->max_invitations(), target); + } + + // optional uint32 reason = 6; + if (has_reason()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->reason(), target); + } + + // optional .bgs.protocol.channel.v1.ChannelState.PrivacyLevel privacy_level = 7 [default = PRIVACY_LEVEL_OPEN]; + if (has_privacy_level()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 7, this->privacy_level(), target); + } + + // optional string name = 8; + 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( + 8, this->name(), target); + } + + // optional string delegate_name = 9; + if (has_delegate_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->delegate_name().data(), this->delegate_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "delegate_name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 9, this->delegate_name(), target); + } + + // optional string channel_type = 10 [default = "default"]; + if (has_channel_type()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->channel_type().data(), this->channel_type().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "channel_type"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 10, this->channel_type(), target); + } + + // optional fixed32 program = 11 [default = 0]; + if (has_program()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(11, this->program(), target); + } + + // optional bool allow_offline_members = 12 [default = false]; + if (has_allow_offline_members()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(12, this->allow_offline_members(), target); + } + + // optional bool subscribe_to_presence = 13 [default = true]; + if (has_subscribe_to_presence()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(13, this->subscribe_to_presence(), target); + } + + // optional bool destroy_on_founder_leave = 14 [default = false]; + if (has_destroy_on_founder_leave()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(14, this->destroy_on_founder_leave(), target); + } + + // Extension range [100, 10000) + target = _extensions_.SerializeWithCachedSizesToArray( + 100, 10000, target); + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.ChannelState) + return target; +} + +int ChannelState::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional uint32 max_members = 1; + if (has_max_members()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->max_members()); + } + + // optional uint32 min_members = 2; + if (has_min_members()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->min_members()); + } + + // optional uint32 max_invitations = 5; + if (has_max_invitations()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->max_invitations()); + } + + // optional uint32 reason = 6; + if (has_reason()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->reason()); + } + + // optional .bgs.protocol.channel.v1.ChannelState.PrivacyLevel privacy_level = 7 [default = PRIVACY_LEVEL_OPEN]; + if (has_privacy_level()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->privacy_level()); + } + + // optional string name = 8; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + } + if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + // optional string delegate_name = 9; + if (has_delegate_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->delegate_name()); + } + + // optional string channel_type = 10 [default = "default"]; + if (has_channel_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->channel_type()); + } + + // optional fixed32 program = 11 [default = 0]; + if (has_program()) { + total_size += 1 + 4; + } + + // optional bool allow_offline_members = 12 [default = false]; + if (has_allow_offline_members()) { + total_size += 1 + 1; + } + + // optional bool subscribe_to_presence = 13 [default = true]; + if (has_subscribe_to_presence()) { + total_size += 1 + 1; + } + + // optional bool destroy_on_founder_leave = 14 [default = false]; + if (has_destroy_on_founder_leave()) { + total_size += 1 + 1; + } + + } + // repeated .bgs.protocol.Attribute attribute = 3; + total_size += 1 * this->attribute_size(); + for (int i = 0; i < this->attribute_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->attribute(i)); + } + + // repeated .bgs.protocol.Invitation invitation = 4; + total_size += 1 * this->invitation_size(); + for (int i = 0; i < this->invitation_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->invitation(i)); + } + + total_size += _extensions_.ByteSize(); + + 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 ChannelState::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ChannelState* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ChannelState::MergeFrom(const ChannelState& from) { + GOOGLE_CHECK_NE(&from, this); + attribute_.MergeFrom(from.attribute_); + invitation_.MergeFrom(from.invitation_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_max_members()) { + set_max_members(from.max_members()); + } + if (from.has_min_members()) { + set_min_members(from.min_members()); + } + if (from.has_max_invitations()) { + set_max_invitations(from.max_invitations()); + } + if (from.has_reason()) { + set_reason(from.reason()); + } + if (from.has_privacy_level()) { + set_privacy_level(from.privacy_level()); + } + if (from.has_name()) { + set_name(from.name()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from.has_delegate_name()) { + set_delegate_name(from.delegate_name()); + } + if (from.has_channel_type()) { + set_channel_type(from.channel_type()); + } + if (from.has_program()) { + set_program(from.program()); + } + if (from.has_allow_offline_members()) { + set_allow_offline_members(from.allow_offline_members()); + } + if (from.has_subscribe_to_presence()) { + set_subscribe_to_presence(from.subscribe_to_presence()); + } + if (from.has_destroy_on_founder_leave()) { + set_destroy_on_founder_leave(from.destroy_on_founder_leave()); + } + } + _extensions_.MergeFrom(from._extensions_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ChannelState::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ChannelState::CopyFrom(const ChannelState& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ChannelState::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false; + if (!::google::protobuf::internal::AllAreInitialized(this->invitation())) return false; + + if (!_extensions_.IsInitialized()) return false; return true; +} + +void ChannelState::Swap(ChannelState* other) { + if (other != this) { + std::swap(max_members_, other->max_members_); + std::swap(min_members_, other->min_members_); + attribute_.Swap(&other->attribute_); + invitation_.Swap(&other->invitation_); + std::swap(max_invitations_, other->max_invitations_); + std::swap(reason_, other->reason_); + std::swap(privacy_level_, other->privacy_level_); + std::swap(name_, other->name_); + std::swap(delegate_name_, other->delegate_name_); + std::swap(channel_type_, other->channel_type_); + std::swap(program_, other->program_); + std::swap(allow_offline_members_, other->allow_offline_members_); + std::swap(subscribe_to_presence_, other->subscribe_to_presence_); + std::swap(destroy_on_founder_leave_, other->destroy_on_founder_leave_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + _extensions_.Swap(&other->_extensions_); + } +} + +::google::protobuf::Metadata ChannelState::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ChannelState_descriptor_; + metadata.reflection = ChannelState_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int MemberState::kAttributeFieldNumber; +const int MemberState::kRoleFieldNumber; +const int MemberState::kPrivilegesFieldNumber; +const int MemberState::kInfoFieldNumber; +const int MemberState::kDEPRECATEDHiddenFieldNumber; +#endif // !_MSC_VER + +MemberState::MemberState() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.MemberState) +} + +void MemberState::InitAsDefaultInstance() { + info_ = const_cast< ::bgs::protocol::AccountInfo*>(&::bgs::protocol::AccountInfo::default_instance()); +} + +MemberState::MemberState(const MemberState& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.MemberState) +} + +void MemberState::SharedCtor() { + _cached_size_ = 0; + privileges_ = GOOGLE_ULONGLONG(0); + info_ = NULL; + deprecated_hidden_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +MemberState::~MemberState() { + // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.MemberState) + SharedDtor(); +} + +void MemberState::SharedDtor() { + if (this != default_instance_) { + delete info_; + } +} + +void MemberState::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* MemberState::descriptor() { + protobuf_AssignDescriptorsOnce(); + return MemberState_descriptor_; +} + +const MemberState& MemberState::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_channel_5ftypes_2eproto(); + return *default_instance_; +} + +MemberState* MemberState::default_instance_ = NULL; + +MemberState* MemberState::New() const { + return new MemberState; +} + +void MemberState::Clear() { + _extensions_.Clear(); + if (_has_bits_[0 / 32] & 28) { + privileges_ = GOOGLE_ULONGLONG(0); + if (has_info()) { + if (info_ != NULL) info_->::bgs::protocol::AccountInfo::Clear(); + } + deprecated_hidden_ = false; + } + attribute_.Clear(); + role_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool MemberState::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.MemberState) + 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 .bgs.protocol.Attribute attribute = 1; + case 1: { + if (tag == 10) { + parse_attribute: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_attribute())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_attribute; + if (input->ExpectTag(18)) goto parse_role; + break; + } + + // repeated uint32 role = 2 [packed = true]; + case 2: { + if (tag == 18) { + parse_role: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_role()))); + } else if (tag == 16) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 18, input, this->mutable_role()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_privileges; + break; + } + + // optional uint64 privileges = 3 [default = 0]; + case 3: { + if (tag == 24) { + parse_privileges: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &privileges_))); + set_has_privileges(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_info; + break; + } + + // optional .bgs.protocol.AccountInfo info = 4; + case 4: { + if (tag == 34) { + parse_info: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_info())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_DEPRECATED_hidden; + break; + } + + // optional bool DEPRECATED_hidden = 5 [default = false, deprecated = true]; + case 5: { + if (tag == 40) { + parse_DEPRECATED_hidden: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &deprecated_hidden_))); + set_has_deprecated_hidden(); + } 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; + } + if ((800u <= tag && tag < 80000u)) { + DO_(_extensions_.ParseField(tag, input, default_instance_, + mutable_unknown_fields())); + continue; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.MemberState) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.MemberState) + return false; +#undef DO_ +} + +void MemberState::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.MemberState) + // repeated .bgs.protocol.Attribute attribute = 1; + for (int i = 0; i < this->attribute_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->attribute(i), output); + } + + // repeated uint32 role = 2 [packed = true]; + if (this->role_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(2, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_role_cached_byte_size_); + } + for (int i = 0; i < this->role_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag( + this->role(i), output); + } + + // optional uint64 privileges = 3 [default = 0]; + if (has_privileges()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->privileges(), output); + } + + // optional .bgs.protocol.AccountInfo info = 4; + if (has_info()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->info(), output); + } + + // optional bool DEPRECATED_hidden = 5 [default = false, deprecated = true]; + if (has_deprecated_hidden()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->deprecated_hidden(), output); + } + + // Extension range [100, 10000) + _extensions_.SerializeWithCachedSizes( + 100, 10000, output); + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.MemberState) +} + +::google::protobuf::uint8* MemberState::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.MemberState) + // repeated .bgs.protocol.Attribute attribute = 1; + for (int i = 0; i < this->attribute_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->attribute(i), target); + } + + // repeated uint32 role = 2 [packed = true]; + if (this->role_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 2, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _role_cached_byte_size_, target); + } + for (int i = 0; i < this->role_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32NoTagToArray(this->role(i), target); + } + + // optional uint64 privileges = 3 [default = 0]; + if (has_privileges()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->privileges(), target); + } + + // optional .bgs.protocol.AccountInfo info = 4; + if (has_info()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->info(), target); + } + + // optional bool DEPRECATED_hidden = 5 [default = false, deprecated = true]; + if (has_deprecated_hidden()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->deprecated_hidden(), target); + } + + // Extension range [100, 10000) + target = _extensions_.SerializeWithCachedSizesToArray( + 100, 10000, target); + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.MemberState) + return target; +} + +int MemberState::ByteSize() const { + int total_size = 0; + + if (_has_bits_[2 / 32] & (0xffu << (2 % 32))) { + // optional uint64 privileges = 3 [default = 0]; + if (has_privileges()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->privileges()); + } + + // optional .bgs.protocol.AccountInfo info = 4; + if (has_info()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->info()); + } + + // optional bool DEPRECATED_hidden = 5 [default = false, deprecated = true]; + if (has_deprecated_hidden()) { + total_size += 1 + 1; + } + + } + // repeated .bgs.protocol.Attribute attribute = 1; + total_size += 1 * this->attribute_size(); + for (int i = 0; i < this->attribute_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->attribute(i)); + } + + // repeated uint32 role = 2 [packed = true]; + { + int data_size = 0; + for (int i = 0; i < this->role_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->role(i)); + } + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _role_cached_byte_size_ = data_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + total_size += _extensions_.ByteSize(); + + 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 MemberState::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const MemberState* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void MemberState::MergeFrom(const MemberState& from) { + GOOGLE_CHECK_NE(&from, this); + attribute_.MergeFrom(from.attribute_); + role_.MergeFrom(from.role_); + if (from._has_bits_[2 / 32] & (0xffu << (2 % 32))) { + if (from.has_privileges()) { + set_privileges(from.privileges()); + } + if (from.has_info()) { + mutable_info()->::bgs::protocol::AccountInfo::MergeFrom(from.info()); + } + if (from.has_deprecated_hidden()) { + set_deprecated_hidden(from.deprecated_hidden()); + } + } + _extensions_.MergeFrom(from._extensions_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void MemberState::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MemberState::CopyFrom(const MemberState& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MemberState::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false; + if (has_info()) { + if (!this->info().IsInitialized()) return false; + } + + if (!_extensions_.IsInitialized()) return false; return true; +} + +void MemberState::Swap(MemberState* other) { + if (other != this) { + attribute_.Swap(&other->attribute_); + role_.Swap(&other->role_); + std::swap(privileges_, other->privileges_); + std::swap(info_, other->info_); + std::swap(deprecated_hidden_, other->deprecated_hidden_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + _extensions_.Swap(&other->_extensions_); + } +} + +::google::protobuf::Metadata MemberState::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = MemberState_descriptor_; + metadata.reflection = MemberState_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int Member::kIdentityFieldNumber; +const int Member::kStateFieldNumber; +#endif // !_MSC_VER + +Member::Member() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.Member) +} + +void Member::InitAsDefaultInstance() { + identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance()); + state_ = const_cast< ::bgs::protocol::channel::v1::MemberState*>(&::bgs::protocol::channel::v1::MemberState::default_instance()); +} + +Member::Member(const Member& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.Member) +} + +void Member::SharedCtor() { + _cached_size_ = 0; + identity_ = NULL; + state_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Member::~Member() { + // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.Member) + SharedDtor(); +} + +void Member::SharedDtor() { + if (this != default_instance_) { + delete identity_; + delete state_; + } +} + +void Member::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Member::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Member_descriptor_; +} + +const Member& Member::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_channel_5ftypes_2eproto(); + return *default_instance_; +} + +Member* Member::default_instance_ = NULL; + +Member* Member::New() const { + return new Member; +} + +void Member::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_identity()) { + if (identity_ != NULL) identity_->::bgs::protocol::Identity::Clear(); + } + if (has_state()) { + if (state_ != NULL) state_->::bgs::protocol::channel::v1::MemberState::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Member::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.Member) + 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)) { + // required .bgs.protocol.Identity identity = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_identity())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_state; + break; + } + + // required .bgs.protocol.channel.v1.MemberState state = 2; + case 2: { + if (tag == 18) { + parse_state: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_state())); + } 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:bgs.protocol.channel.v1.Member) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.Member) + return false; +#undef DO_ +} + +void Member::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.Member) + // required .bgs.protocol.Identity identity = 1; + if (has_identity()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->identity(), output); + } + + // required .bgs.protocol.channel.v1.MemberState state = 2; + if (has_state()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->state(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.Member) +} + +::google::protobuf::uint8* Member::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.Member) + // required .bgs.protocol.Identity identity = 1; + if (has_identity()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->identity(), target); + } + + // required .bgs.protocol.channel.v1.MemberState state = 2; + if (has_state()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->state(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.Member) + return target; +} + +int Member::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.Identity identity = 1; + if (has_identity()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->identity()); + } + + // required .bgs.protocol.channel.v1.MemberState state = 2; + if (has_state()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->state()); + } + + } + 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 Member::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Member* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Member::MergeFrom(const Member& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_identity()) { + mutable_identity()->::bgs::protocol::Identity::MergeFrom(from.identity()); + } + if (from.has_state()) { + mutable_state()->::bgs::protocol::channel::v1::MemberState::MergeFrom(from.state()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Member::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Member::CopyFrom(const Member& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Member::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + if (has_identity()) { + if (!this->identity().IsInitialized()) return false; + } + if (has_state()) { + if (!this->state().IsInitialized()) return false; + } + return true; +} + +void Member::Swap(Member* other) { + if (other != this) { + std::swap(identity_, other->identity_); + std::swap(state_, other->state_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata Member::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Member_descriptor_; + metadata.reflection = Member_reflection_; + return metadata; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace channel +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/channel_types.pb.h b/src/server/proto/Client/channel_types.pb.h new file mode 100644 index 00000000000..a9651e0955b --- /dev/null +++ b/src/server/proto/Client/channel_types.pb.h @@ -0,0 +1,2550 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: channel_types.proto + +#ifndef PROTOBUF_channel_5ftypes_2eproto__INCLUDED +#define PROTOBUF_channel_5ftypes_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include +#include "attribute_types.pb.h" +#include "entity_types.pb.h" +#include "invitation_types.pb.h" +#include "rpc_types.pb.h" +#include "Define.h" // for TRINITY_SHARED_API +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { +namespace channel { +namespace v1 { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_channel_5ftypes_2eproto(); +void protobuf_AssignDesc_channel_5ftypes_2eproto(); +void protobuf_ShutdownFile_channel_5ftypes_2eproto(); + +class ChannelId; +class Message; +class ListChannelsOptions; +class ChannelDescription; +class ChannelInfo; +class ChannelState; +class MemberState; +class Member; + +enum ChannelState_PrivacyLevel { + ChannelState_PrivacyLevel_PRIVACY_LEVEL_OPEN = 1, + ChannelState_PrivacyLevel_PRIVACY_LEVEL_OPEN_INVITATION_AND_FRIEND = 2, + ChannelState_PrivacyLevel_PRIVACY_LEVEL_OPEN_INVITATION = 3, + ChannelState_PrivacyLevel_PRIVACY_LEVEL_CLOSED = 4 +}; +TC_SHARED_API bool ChannelState_PrivacyLevel_IsValid(int value); +const ChannelState_PrivacyLevel ChannelState_PrivacyLevel_PrivacyLevel_MIN = ChannelState_PrivacyLevel_PRIVACY_LEVEL_OPEN; +const ChannelState_PrivacyLevel ChannelState_PrivacyLevel_PrivacyLevel_MAX = ChannelState_PrivacyLevel_PRIVACY_LEVEL_CLOSED; +const int ChannelState_PrivacyLevel_PrivacyLevel_ARRAYSIZE = ChannelState_PrivacyLevel_PrivacyLevel_MAX + 1; + +TC_SHARED_API const ::google::protobuf::EnumDescriptor* ChannelState_PrivacyLevel_descriptor(); +inline const ::std::string& ChannelState_PrivacyLevel_Name(ChannelState_PrivacyLevel value) { + return ::google::protobuf::internal::NameOfEnum( + ChannelState_PrivacyLevel_descriptor(), value); +} +inline bool ChannelState_PrivacyLevel_Parse( + const ::std::string& name, ChannelState_PrivacyLevel* value) { + return ::google::protobuf::internal::ParseNamedEnum( + ChannelState_PrivacyLevel_descriptor(), name, value); +} +// =================================================================== + +class TC_SHARED_API ChannelId : public ::google::protobuf::Message { + public: + ChannelId(); + virtual ~ChannelId(); + + ChannelId(const ChannelId& from); + + inline ChannelId& operator=(const ChannelId& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ChannelId& default_instance(); + + void Swap(ChannelId* other); + + // implements Message ---------------------------------------------- + + ChannelId* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ChannelId& from); + void MergeFrom(const ChannelId& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint32 type = 1; + inline bool has_type() const; + inline void clear_type(); + static const int kTypeFieldNumber = 1; + inline ::google::protobuf::uint32 type() const; + inline void set_type(::google::protobuf::uint32 value); + + // optional .bgs.protocol.ProcessId host = 2; + inline bool has_host() const; + inline void clear_host(); + static const int kHostFieldNumber = 2; + inline const ::bgs::protocol::ProcessId& host() const; + inline ::bgs::protocol::ProcessId* mutable_host(); + inline ::bgs::protocol::ProcessId* release_host(); + inline void set_allocated_host(::bgs::protocol::ProcessId* host); + + // optional fixed32 id = 3; + inline bool has_id() const; + inline void clear_id(); + static const int kIdFieldNumber = 3; + inline ::google::protobuf::uint32 id() const; + inline void set_id(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.ChannelId) + private: + inline void set_has_type(); + inline void clear_has_type(); + inline void set_has_host(); + inline void clear_has_host(); + inline void set_has_id(); + inline void clear_has_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::ProcessId* host_; + ::google::protobuf::uint32 type_; + ::google::protobuf::uint32 id_; + friend void TC_SHARED_API protobuf_AddDesc_channel_5ftypes_2eproto(); + friend void protobuf_AssignDesc_channel_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_channel_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static ChannelId* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API Message : public ::google::protobuf::Message { + public: + Message(); + virtual ~Message(); + + Message(const Message& from); + + inline Message& operator=(const Message& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Message& default_instance(); + + void Swap(Message* other); + + // implements Message ---------------------------------------------- + + Message* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Message& from); + void MergeFrom(const Message& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.Attribute attribute = 1; + inline int attribute_size() const; + inline void clear_attribute(); + static const int kAttributeFieldNumber = 1; + inline const ::bgs::protocol::Attribute& attribute(int index) const; + inline ::bgs::protocol::Attribute* mutable_attribute(int index); + inline ::bgs::protocol::Attribute* add_attribute(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& + attribute() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* + mutable_attribute(); + + // optional uint32 role = 2; + inline bool has_role() const; + inline void clear_role(); + static const int kRoleFieldNumber = 2; + inline ::google::protobuf::uint32 role() const; + inline void set_role(::google::protobuf::uint32 value); + + GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(Message) + // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.Message) + private: + inline void set_has_role(); + inline void clear_has_role(); + + ::google::protobuf::internal::ExtensionSet _extensions_; + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_; + ::google::protobuf::uint32 role_; + friend void TC_SHARED_API protobuf_AddDesc_channel_5ftypes_2eproto(); + friend void protobuf_AssignDesc_channel_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_channel_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static Message* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ListChannelsOptions : public ::google::protobuf::Message { + public: + ListChannelsOptions(); + virtual ~ListChannelsOptions(); + + ListChannelsOptions(const ListChannelsOptions& from); + + inline ListChannelsOptions& operator=(const ListChannelsOptions& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ListChannelsOptions& default_instance(); + + void Swap(ListChannelsOptions* other); + + // implements Message ---------------------------------------------- + + ListChannelsOptions* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ListChannelsOptions& from); + void MergeFrom(const ListChannelsOptions& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint32 start_index = 1 [default = 0]; + inline bool has_start_index() const; + inline void clear_start_index(); + static const int kStartIndexFieldNumber = 1; + inline ::google::protobuf::uint32 start_index() const; + inline void set_start_index(::google::protobuf::uint32 value); + + // optional uint32 max_results = 2 [default = 16]; + inline bool has_max_results() const; + inline void clear_max_results(); + static const int kMaxResultsFieldNumber = 2; + inline ::google::protobuf::uint32 max_results() const; + inline void set_max_results(::google::protobuf::uint32 value); + + // optional string name = 3; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 3; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + inline ::std::string* release_name(); + inline void set_allocated_name(::std::string* name); + + // optional fixed32 program = 4; + inline bool has_program() const; + inline void clear_program(); + static const int kProgramFieldNumber = 4; + inline ::google::protobuf::uint32 program() const; + inline void set_program(::google::protobuf::uint32 value); + + // optional fixed32 locale = 5; + inline bool has_locale() const; + inline void clear_locale(); + static const int kLocaleFieldNumber = 5; + inline ::google::protobuf::uint32 locale() const; + inline void set_locale(::google::protobuf::uint32 value); + + // optional uint32 capacity_full = 6; + inline bool has_capacity_full() const; + inline void clear_capacity_full(); + static const int kCapacityFullFieldNumber = 6; + inline ::google::protobuf::uint32 capacity_full() const; + inline void set_capacity_full(::google::protobuf::uint32 value); + + // required .bgs.protocol.AttributeFilter attribute_filter = 7; + inline bool has_attribute_filter() const; + inline void clear_attribute_filter(); + static const int kAttributeFilterFieldNumber = 7; + inline const ::bgs::protocol::AttributeFilter& attribute_filter() const; + inline ::bgs::protocol::AttributeFilter* mutable_attribute_filter(); + inline ::bgs::protocol::AttributeFilter* release_attribute_filter(); + inline void set_allocated_attribute_filter(::bgs::protocol::AttributeFilter* attribute_filter); + + // optional string channel_type = 8; + inline bool has_channel_type() const; + inline void clear_channel_type(); + static const int kChannelTypeFieldNumber = 8; + inline const ::std::string& channel_type() const; + inline void set_channel_type(const ::std::string& value); + inline void set_channel_type(const char* value); + inline void set_channel_type(const char* value, size_t size); + inline ::std::string* mutable_channel_type(); + inline ::std::string* release_channel_type(); + inline void set_allocated_channel_type(::std::string* channel_type); + + GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(ListChannelsOptions) + // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.ListChannelsOptions) + private: + inline void set_has_start_index(); + inline void clear_has_start_index(); + inline void set_has_max_results(); + inline void clear_has_max_results(); + inline void set_has_name(); + inline void clear_has_name(); + inline void set_has_program(); + inline void clear_has_program(); + inline void set_has_locale(); + inline void clear_has_locale(); + inline void set_has_capacity_full(); + inline void clear_has_capacity_full(); + inline void set_has_attribute_filter(); + inline void clear_has_attribute_filter(); + inline void set_has_channel_type(); + inline void clear_has_channel_type(); + + ::google::protobuf::internal::ExtensionSet _extensions_; + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 start_index_; + ::google::protobuf::uint32 max_results_; + ::std::string* name_; + ::google::protobuf::uint32 program_; + ::google::protobuf::uint32 locale_; + ::bgs::protocol::AttributeFilter* attribute_filter_; + ::std::string* channel_type_; + ::google::protobuf::uint32 capacity_full_; + friend void TC_SHARED_API protobuf_AddDesc_channel_5ftypes_2eproto(); + friend void protobuf_AssignDesc_channel_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_channel_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static ListChannelsOptions* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ChannelDescription : public ::google::protobuf::Message { + public: + ChannelDescription(); + virtual ~ChannelDescription(); + + ChannelDescription(const ChannelDescription& from); + + inline ChannelDescription& operator=(const ChannelDescription& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ChannelDescription& default_instance(); + + void Swap(ChannelDescription* other); + + // implements Message ---------------------------------------------- + + ChannelDescription* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ChannelDescription& from); + void MergeFrom(const ChannelDescription& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.EntityId channel_id = 1; + inline bool has_channel_id() const; + inline void clear_channel_id(); + static const int kChannelIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& channel_id() const; + inline ::bgs::protocol::EntityId* mutable_channel_id(); + inline ::bgs::protocol::EntityId* release_channel_id(); + inline void set_allocated_channel_id(::bgs::protocol::EntityId* channel_id); + + // optional uint32 current_members = 2; + inline bool has_current_members() const; + inline void clear_current_members(); + static const int kCurrentMembersFieldNumber = 2; + inline ::google::protobuf::uint32 current_members() const; + inline void set_current_members(::google::protobuf::uint32 value); + + // optional .bgs.protocol.channel.v1.ChannelState state = 3; + inline bool has_state() const; + inline void clear_state(); + static const int kStateFieldNumber = 3; + inline const ::bgs::protocol::channel::v1::ChannelState& state() const; + inline ::bgs::protocol::channel::v1::ChannelState* mutable_state(); + inline ::bgs::protocol::channel::v1::ChannelState* release_state(); + inline void set_allocated_state(::bgs::protocol::channel::v1::ChannelState* state); + + // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.ChannelDescription) + private: + inline void set_has_channel_id(); + inline void clear_has_channel_id(); + inline void set_has_current_members(); + inline void clear_has_current_members(); + inline void set_has_state(); + inline void clear_has_state(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* channel_id_; + ::bgs::protocol::channel::v1::ChannelState* state_; + ::google::protobuf::uint32 current_members_; + friend void TC_SHARED_API protobuf_AddDesc_channel_5ftypes_2eproto(); + friend void protobuf_AssignDesc_channel_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_channel_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static ChannelDescription* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ChannelInfo : public ::google::protobuf::Message { + public: + ChannelInfo(); + virtual ~ChannelInfo(); + + ChannelInfo(const ChannelInfo& from); + + inline ChannelInfo& operator=(const ChannelInfo& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ChannelInfo& default_instance(); + + void Swap(ChannelInfo* other); + + // implements Message ---------------------------------------------- + + ChannelInfo* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ChannelInfo& from); + void MergeFrom(const ChannelInfo& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.channel.v1.ChannelDescription description = 1; + inline bool has_description() const; + inline void clear_description(); + static const int kDescriptionFieldNumber = 1; + inline const ::bgs::protocol::channel::v1::ChannelDescription& description() const; + inline ::bgs::protocol::channel::v1::ChannelDescription* mutable_description(); + inline ::bgs::protocol::channel::v1::ChannelDescription* release_description(); + inline void set_allocated_description(::bgs::protocol::channel::v1::ChannelDescription* description); + + // repeated .bgs.protocol.channel.v1.Member member = 2; + inline int member_size() const; + inline void clear_member(); + static const int kMemberFieldNumber = 2; + inline const ::bgs::protocol::channel::v1::Member& member(int index) const; + inline ::bgs::protocol::channel::v1::Member* mutable_member(int index); + inline ::bgs::protocol::channel::v1::Member* add_member(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >& + member() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >* + mutable_member(); + + GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(ChannelInfo) + // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.ChannelInfo) + private: + inline void set_has_description(); + inline void clear_has_description(); + + ::google::protobuf::internal::ExtensionSet _extensions_; + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::channel::v1::ChannelDescription* description_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member > member_; + friend void TC_SHARED_API protobuf_AddDesc_channel_5ftypes_2eproto(); + friend void protobuf_AssignDesc_channel_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_channel_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static ChannelInfo* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ChannelState : public ::google::protobuf::Message { + public: + ChannelState(); + virtual ~ChannelState(); + + ChannelState(const ChannelState& from); + + inline ChannelState& operator=(const ChannelState& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ChannelState& default_instance(); + + void Swap(ChannelState* other); + + // implements Message ---------------------------------------------- + + ChannelState* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ChannelState& from); + void MergeFrom(const ChannelState& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef ChannelState_PrivacyLevel PrivacyLevel; + static const PrivacyLevel PRIVACY_LEVEL_OPEN = ChannelState_PrivacyLevel_PRIVACY_LEVEL_OPEN; + static const PrivacyLevel PRIVACY_LEVEL_OPEN_INVITATION_AND_FRIEND = ChannelState_PrivacyLevel_PRIVACY_LEVEL_OPEN_INVITATION_AND_FRIEND; + static const PrivacyLevel PRIVACY_LEVEL_OPEN_INVITATION = ChannelState_PrivacyLevel_PRIVACY_LEVEL_OPEN_INVITATION; + static const PrivacyLevel PRIVACY_LEVEL_CLOSED = ChannelState_PrivacyLevel_PRIVACY_LEVEL_CLOSED; + static inline bool PrivacyLevel_IsValid(int value) { + return ChannelState_PrivacyLevel_IsValid(value); + } + static const PrivacyLevel PrivacyLevel_MIN = + ChannelState_PrivacyLevel_PrivacyLevel_MIN; + static const PrivacyLevel PrivacyLevel_MAX = + ChannelState_PrivacyLevel_PrivacyLevel_MAX; + static const int PrivacyLevel_ARRAYSIZE = + ChannelState_PrivacyLevel_PrivacyLevel_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + PrivacyLevel_descriptor() { + return ChannelState_PrivacyLevel_descriptor(); + } + static inline const ::std::string& PrivacyLevel_Name(PrivacyLevel value) { + return ChannelState_PrivacyLevel_Name(value); + } + static inline bool PrivacyLevel_Parse(const ::std::string& name, + PrivacyLevel* value) { + return ChannelState_PrivacyLevel_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // optional uint32 max_members = 1; + inline bool has_max_members() const; + inline void clear_max_members(); + static const int kMaxMembersFieldNumber = 1; + inline ::google::protobuf::uint32 max_members() const; + inline void set_max_members(::google::protobuf::uint32 value); + + // optional uint32 min_members = 2; + inline bool has_min_members() const; + inline void clear_min_members(); + static const int kMinMembersFieldNumber = 2; + inline ::google::protobuf::uint32 min_members() const; + inline void set_min_members(::google::protobuf::uint32 value); + + // repeated .bgs.protocol.Attribute attribute = 3; + inline int attribute_size() const; + inline void clear_attribute(); + static const int kAttributeFieldNumber = 3; + inline const ::bgs::protocol::Attribute& attribute(int index) const; + inline ::bgs::protocol::Attribute* mutable_attribute(int index); + inline ::bgs::protocol::Attribute* add_attribute(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& + attribute() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* + mutable_attribute(); + + // repeated .bgs.protocol.Invitation invitation = 4; + inline int invitation_size() const; + inline void clear_invitation(); + static const int kInvitationFieldNumber = 4; + inline const ::bgs::protocol::Invitation& invitation(int index) const; + inline ::bgs::protocol::Invitation* mutable_invitation(int index); + inline ::bgs::protocol::Invitation* add_invitation(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >& + invitation() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >* + mutable_invitation(); + + // optional uint32 max_invitations = 5; + inline bool has_max_invitations() const; + inline void clear_max_invitations(); + static const int kMaxInvitationsFieldNumber = 5; + inline ::google::protobuf::uint32 max_invitations() const; + inline void set_max_invitations(::google::protobuf::uint32 value); + + // optional uint32 reason = 6; + inline bool has_reason() const; + inline void clear_reason(); + static const int kReasonFieldNumber = 6; + inline ::google::protobuf::uint32 reason() const; + inline void set_reason(::google::protobuf::uint32 value); + + // optional .bgs.protocol.channel.v1.ChannelState.PrivacyLevel privacy_level = 7 [default = PRIVACY_LEVEL_OPEN]; + inline bool has_privacy_level() const; + inline void clear_privacy_level(); + static const int kPrivacyLevelFieldNumber = 7; + inline ::bgs::protocol::channel::v1::ChannelState_PrivacyLevel privacy_level() const; + inline void set_privacy_level(::bgs::protocol::channel::v1::ChannelState_PrivacyLevel value); + + // optional string name = 8; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 8; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + inline ::std::string* release_name(); + inline void set_allocated_name(::std::string* name); + + // optional string delegate_name = 9; + inline bool has_delegate_name() const; + inline void clear_delegate_name(); + static const int kDelegateNameFieldNumber = 9; + inline const ::std::string& delegate_name() const; + inline void set_delegate_name(const ::std::string& value); + inline void set_delegate_name(const char* value); + inline void set_delegate_name(const char* value, size_t size); + inline ::std::string* mutable_delegate_name(); + inline ::std::string* release_delegate_name(); + inline void set_allocated_delegate_name(::std::string* delegate_name); + + // optional string channel_type = 10 [default = "default"]; + inline bool has_channel_type() const; + inline void clear_channel_type(); + static const int kChannelTypeFieldNumber = 10; + inline const ::std::string& channel_type() const; + inline void set_channel_type(const ::std::string& value); + inline void set_channel_type(const char* value); + inline void set_channel_type(const char* value, size_t size); + inline ::std::string* mutable_channel_type(); + inline ::std::string* release_channel_type(); + inline void set_allocated_channel_type(::std::string* channel_type); + + // optional fixed32 program = 11 [default = 0]; + inline bool has_program() const; + inline void clear_program(); + static const int kProgramFieldNumber = 11; + inline ::google::protobuf::uint32 program() const; + inline void set_program(::google::protobuf::uint32 value); + + // optional bool allow_offline_members = 12 [default = false]; + inline bool has_allow_offline_members() const; + inline void clear_allow_offline_members(); + static const int kAllowOfflineMembersFieldNumber = 12; + inline bool allow_offline_members() const; + inline void set_allow_offline_members(bool value); + + // optional bool subscribe_to_presence = 13 [default = true]; + inline bool has_subscribe_to_presence() const; + inline void clear_subscribe_to_presence(); + static const int kSubscribeToPresenceFieldNumber = 13; + inline bool subscribe_to_presence() const; + inline void set_subscribe_to_presence(bool value); + + // optional bool destroy_on_founder_leave = 14 [default = false]; + inline bool has_destroy_on_founder_leave() const; + inline void clear_destroy_on_founder_leave(); + static const int kDestroyOnFounderLeaveFieldNumber = 14; + inline bool destroy_on_founder_leave() const; + inline void set_destroy_on_founder_leave(bool value); + + GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(ChannelState) + // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.ChannelState) + private: + inline void set_has_max_members(); + inline void clear_has_max_members(); + inline void set_has_min_members(); + inline void clear_has_min_members(); + inline void set_has_max_invitations(); + inline void clear_has_max_invitations(); + inline void set_has_reason(); + inline void clear_has_reason(); + inline void set_has_privacy_level(); + inline void clear_has_privacy_level(); + inline void set_has_name(); + inline void clear_has_name(); + inline void set_has_delegate_name(); + inline void clear_has_delegate_name(); + inline void set_has_channel_type(); + inline void clear_has_channel_type(); + inline void set_has_program(); + inline void clear_has_program(); + inline void set_has_allow_offline_members(); + inline void clear_has_allow_offline_members(); + inline void set_has_subscribe_to_presence(); + inline void clear_has_subscribe_to_presence(); + inline void set_has_destroy_on_founder_leave(); + inline void clear_has_destroy_on_founder_leave(); + + ::google::protobuf::internal::ExtensionSet _extensions_; + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 max_members_; + ::google::protobuf::uint32 min_members_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation > invitation_; + ::google::protobuf::uint32 max_invitations_; + ::google::protobuf::uint32 reason_; + ::std::string* name_; + ::std::string* delegate_name_; + int privacy_level_; + ::google::protobuf::uint32 program_; + static ::std::string* _default_channel_type_; + ::std::string* channel_type_; + bool allow_offline_members_; + bool subscribe_to_presence_; + bool destroy_on_founder_leave_; + friend void TC_SHARED_API protobuf_AddDesc_channel_5ftypes_2eproto(); + friend void protobuf_AssignDesc_channel_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_channel_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static ChannelState* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API MemberState : public ::google::protobuf::Message { + public: + MemberState(); + virtual ~MemberState(); + + MemberState(const MemberState& from); + + inline MemberState& operator=(const MemberState& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const MemberState& default_instance(); + + void Swap(MemberState* other); + + // implements Message ---------------------------------------------- + + MemberState* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const MemberState& from); + void MergeFrom(const MemberState& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.Attribute attribute = 1; + inline int attribute_size() const; + inline void clear_attribute(); + static const int kAttributeFieldNumber = 1; + inline const ::bgs::protocol::Attribute& attribute(int index) const; + inline ::bgs::protocol::Attribute* mutable_attribute(int index); + inline ::bgs::protocol::Attribute* add_attribute(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& + attribute() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* + mutable_attribute(); + + // repeated uint32 role = 2 [packed = true]; + inline int role_size() const; + inline void clear_role(); + static const int kRoleFieldNumber = 2; + inline ::google::protobuf::uint32 role(int index) const; + inline void set_role(int index, ::google::protobuf::uint32 value); + inline void add_role(::google::protobuf::uint32 value); + inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + role() const; + inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_role(); + + // optional uint64 privileges = 3 [default = 0]; + inline bool has_privileges() const; + inline void clear_privileges(); + static const int kPrivilegesFieldNumber = 3; + inline ::google::protobuf::uint64 privileges() const; + inline void set_privileges(::google::protobuf::uint64 value); + + // optional .bgs.protocol.AccountInfo info = 4; + inline bool has_info() const; + inline void clear_info(); + static const int kInfoFieldNumber = 4; + inline const ::bgs::protocol::AccountInfo& info() const; + inline ::bgs::protocol::AccountInfo* mutable_info(); + inline ::bgs::protocol::AccountInfo* release_info(); + inline void set_allocated_info(::bgs::protocol::AccountInfo* info); + + // optional bool DEPRECATED_hidden = 5 [default = false, deprecated = true]; + inline bool has_deprecated_hidden() const PROTOBUF_DEPRECATED; + inline void clear_deprecated_hidden() PROTOBUF_DEPRECATED; + static const int kDEPRECATEDHiddenFieldNumber = 5; + inline bool deprecated_hidden() const PROTOBUF_DEPRECATED; + inline void set_deprecated_hidden(bool value) PROTOBUF_DEPRECATED; + + GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(MemberState) + // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.MemberState) + private: + inline void set_has_privileges(); + inline void clear_has_privileges(); + inline void set_has_info(); + inline void clear_has_info(); + inline void set_has_deprecated_hidden(); + inline void clear_has_deprecated_hidden(); + + ::google::protobuf::internal::ExtensionSet _extensions_; + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > role_; + mutable int _role_cached_byte_size_; + ::google::protobuf::uint64 privileges_; + ::bgs::protocol::AccountInfo* info_; + bool deprecated_hidden_; + friend void TC_SHARED_API protobuf_AddDesc_channel_5ftypes_2eproto(); + friend void protobuf_AssignDesc_channel_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_channel_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static MemberState* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API Member : public ::google::protobuf::Message { + public: + Member(); + virtual ~Member(); + + Member(const Member& from); + + inline Member& operator=(const Member& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Member& default_instance(); + + void Swap(Member* other); + + // implements Message ---------------------------------------------- + + Member* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Member& from); + void MergeFrom(const Member& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.Identity identity = 1; + inline bool has_identity() const; + inline void clear_identity(); + static const int kIdentityFieldNumber = 1; + inline const ::bgs::protocol::Identity& identity() const; + inline ::bgs::protocol::Identity* mutable_identity(); + inline ::bgs::protocol::Identity* release_identity(); + inline void set_allocated_identity(::bgs::protocol::Identity* identity); + + // required .bgs.protocol.channel.v1.MemberState state = 2; + inline bool has_state() const; + inline void clear_state(); + static const int kStateFieldNumber = 2; + inline const ::bgs::protocol::channel::v1::MemberState& state() const; + inline ::bgs::protocol::channel::v1::MemberState* mutable_state(); + inline ::bgs::protocol::channel::v1::MemberState* release_state(); + inline void set_allocated_state(::bgs::protocol::channel::v1::MemberState* state); + + // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.Member) + private: + inline void set_has_identity(); + inline void clear_has_identity(); + inline void set_has_state(); + inline void clear_has_state(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::Identity* identity_; + ::bgs::protocol::channel::v1::MemberState* state_; + friend void TC_SHARED_API protobuf_AddDesc_channel_5ftypes_2eproto(); + friend void protobuf_AssignDesc_channel_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_channel_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static Member* default_instance_; +}; +// =================================================================== + + +// =================================================================== + + +// =================================================================== + +// ChannelId + +// optional uint32 type = 1; +inline bool ChannelId::has_type() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ChannelId::set_has_type() { + _has_bits_[0] |= 0x00000001u; +} +inline void ChannelId::clear_has_type() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ChannelId::clear_type() { + type_ = 0u; + clear_has_type(); +} +inline ::google::protobuf::uint32 ChannelId::type() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelId.type) + return type_; +} +inline void ChannelId::set_type(::google::protobuf::uint32 value) { + set_has_type(); + type_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelId.type) +} + +// optional .bgs.protocol.ProcessId host = 2; +inline bool ChannelId::has_host() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ChannelId::set_has_host() { + _has_bits_[0] |= 0x00000002u; +} +inline void ChannelId::clear_has_host() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ChannelId::clear_host() { + if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear(); + clear_has_host(); +} +inline const ::bgs::protocol::ProcessId& ChannelId::host() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelId.host) + return host_ != NULL ? *host_ : *default_instance_->host_; +} +inline ::bgs::protocol::ProcessId* ChannelId::mutable_host() { + set_has_host(); + if (host_ == NULL) host_ = new ::bgs::protocol::ProcessId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelId.host) + return host_; +} +inline ::bgs::protocol::ProcessId* ChannelId::release_host() { + clear_has_host(); + ::bgs::protocol::ProcessId* temp = host_; + host_ = NULL; + return temp; +} +inline void ChannelId::set_allocated_host(::bgs::protocol::ProcessId* host) { + delete host_; + host_ = host; + if (host) { + set_has_host(); + } else { + clear_has_host(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ChannelId.host) +} + +// optional fixed32 id = 3; +inline bool ChannelId::has_id() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ChannelId::set_has_id() { + _has_bits_[0] |= 0x00000004u; +} +inline void ChannelId::clear_has_id() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ChannelId::clear_id() { + id_ = 0u; + clear_has_id(); +} +inline ::google::protobuf::uint32 ChannelId::id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelId.id) + return id_; +} +inline void ChannelId::set_id(::google::protobuf::uint32 value) { + set_has_id(); + id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelId.id) +} + +// ------------------------------------------------------------------- + +// Message + +// repeated .bgs.protocol.Attribute attribute = 1; +inline int Message::attribute_size() const { + return attribute_.size(); +} +inline void Message::clear_attribute() { + attribute_.Clear(); +} +inline const ::bgs::protocol::Attribute& Message::attribute(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.Message.attribute) + return attribute_.Get(index); +} +inline ::bgs::protocol::Attribute* Message::mutable_attribute(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.Message.attribute) + return attribute_.Mutable(index); +} +inline ::bgs::protocol::Attribute* Message::add_attribute() { + // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.Message.attribute) + return attribute_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& +Message::attribute() const { + // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.Message.attribute) + return attribute_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* +Message::mutable_attribute() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.Message.attribute) + return &attribute_; +} + +// optional uint32 role = 2; +inline bool Message::has_role() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Message::set_has_role() { + _has_bits_[0] |= 0x00000002u; +} +inline void Message::clear_has_role() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Message::clear_role() { + role_ = 0u; + clear_has_role(); +} +inline ::google::protobuf::uint32 Message::role() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.Message.role) + return role_; +} +inline void Message::set_role(::google::protobuf::uint32 value) { + set_has_role(); + role_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.Message.role) +} + +// ------------------------------------------------------------------- + +// ListChannelsOptions + +// optional uint32 start_index = 1 [default = 0]; +inline bool ListChannelsOptions::has_start_index() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ListChannelsOptions::set_has_start_index() { + _has_bits_[0] |= 0x00000001u; +} +inline void ListChannelsOptions::clear_has_start_index() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ListChannelsOptions::clear_start_index() { + start_index_ = 0u; + clear_has_start_index(); +} +inline ::google::protobuf::uint32 ListChannelsOptions::start_index() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ListChannelsOptions.start_index) + return start_index_; +} +inline void ListChannelsOptions::set_start_index(::google::protobuf::uint32 value) { + set_has_start_index(); + start_index_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ListChannelsOptions.start_index) +} + +// optional uint32 max_results = 2 [default = 16]; +inline bool ListChannelsOptions::has_max_results() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ListChannelsOptions::set_has_max_results() { + _has_bits_[0] |= 0x00000002u; +} +inline void ListChannelsOptions::clear_has_max_results() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ListChannelsOptions::clear_max_results() { + max_results_ = 16u; + clear_has_max_results(); +} +inline ::google::protobuf::uint32 ListChannelsOptions::max_results() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ListChannelsOptions.max_results) + return max_results_; +} +inline void ListChannelsOptions::set_max_results(::google::protobuf::uint32 value) { + set_has_max_results(); + max_results_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ListChannelsOptions.max_results) +} + +// optional string name = 3; +inline bool ListChannelsOptions::has_name() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ListChannelsOptions::set_has_name() { + _has_bits_[0] |= 0x00000004u; +} +inline void ListChannelsOptions::clear_has_name() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ListChannelsOptions::clear_name() { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& ListChannelsOptions::name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ListChannelsOptions.name) + return *name_; +} +inline void ListChannelsOptions::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ListChannelsOptions.name) +} +inline void ListChannelsOptions::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.channel.v1.ListChannelsOptions.name) +} +inline void ListChannelsOptions::set_name(const char* value, size_t size) { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.channel.v1.ListChannelsOptions.name) +} +inline ::std::string* ListChannelsOptions::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ListChannelsOptions.name) + return name_; +} +inline ::std::string* ListChannelsOptions::release_name() { + clear_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = name_; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ListChannelsOptions::set_allocated_name(::std::string* name) { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete name_; + } + if (name) { + set_has_name(); + name_ = name; + } else { + clear_has_name(); + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ListChannelsOptions.name) +} + +// optional fixed32 program = 4; +inline bool ListChannelsOptions::has_program() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void ListChannelsOptions::set_has_program() { + _has_bits_[0] |= 0x00000008u; +} +inline void ListChannelsOptions::clear_has_program() { + _has_bits_[0] &= ~0x00000008u; +} +inline void ListChannelsOptions::clear_program() { + program_ = 0u; + clear_has_program(); +} +inline ::google::protobuf::uint32 ListChannelsOptions::program() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ListChannelsOptions.program) + return program_; +} +inline void ListChannelsOptions::set_program(::google::protobuf::uint32 value) { + set_has_program(); + program_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ListChannelsOptions.program) +} + +// optional fixed32 locale = 5; +inline bool ListChannelsOptions::has_locale() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void ListChannelsOptions::set_has_locale() { + _has_bits_[0] |= 0x00000010u; +} +inline void ListChannelsOptions::clear_has_locale() { + _has_bits_[0] &= ~0x00000010u; +} +inline void ListChannelsOptions::clear_locale() { + locale_ = 0u; + clear_has_locale(); +} +inline ::google::protobuf::uint32 ListChannelsOptions::locale() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ListChannelsOptions.locale) + return locale_; +} +inline void ListChannelsOptions::set_locale(::google::protobuf::uint32 value) { + set_has_locale(); + locale_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ListChannelsOptions.locale) +} + +// optional uint32 capacity_full = 6; +inline bool ListChannelsOptions::has_capacity_full() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void ListChannelsOptions::set_has_capacity_full() { + _has_bits_[0] |= 0x00000020u; +} +inline void ListChannelsOptions::clear_has_capacity_full() { + _has_bits_[0] &= ~0x00000020u; +} +inline void ListChannelsOptions::clear_capacity_full() { + capacity_full_ = 0u; + clear_has_capacity_full(); +} +inline ::google::protobuf::uint32 ListChannelsOptions::capacity_full() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ListChannelsOptions.capacity_full) + return capacity_full_; +} +inline void ListChannelsOptions::set_capacity_full(::google::protobuf::uint32 value) { + set_has_capacity_full(); + capacity_full_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ListChannelsOptions.capacity_full) +} + +// required .bgs.protocol.AttributeFilter attribute_filter = 7; +inline bool ListChannelsOptions::has_attribute_filter() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void ListChannelsOptions::set_has_attribute_filter() { + _has_bits_[0] |= 0x00000040u; +} +inline void ListChannelsOptions::clear_has_attribute_filter() { + _has_bits_[0] &= ~0x00000040u; +} +inline void ListChannelsOptions::clear_attribute_filter() { + if (attribute_filter_ != NULL) attribute_filter_->::bgs::protocol::AttributeFilter::Clear(); + clear_has_attribute_filter(); +} +inline const ::bgs::protocol::AttributeFilter& ListChannelsOptions::attribute_filter() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ListChannelsOptions.attribute_filter) + return attribute_filter_ != NULL ? *attribute_filter_ : *default_instance_->attribute_filter_; +} +inline ::bgs::protocol::AttributeFilter* ListChannelsOptions::mutable_attribute_filter() { + set_has_attribute_filter(); + if (attribute_filter_ == NULL) attribute_filter_ = new ::bgs::protocol::AttributeFilter; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ListChannelsOptions.attribute_filter) + return attribute_filter_; +} +inline ::bgs::protocol::AttributeFilter* ListChannelsOptions::release_attribute_filter() { + clear_has_attribute_filter(); + ::bgs::protocol::AttributeFilter* temp = attribute_filter_; + attribute_filter_ = NULL; + return temp; +} +inline void ListChannelsOptions::set_allocated_attribute_filter(::bgs::protocol::AttributeFilter* attribute_filter) { + delete attribute_filter_; + attribute_filter_ = attribute_filter; + if (attribute_filter) { + set_has_attribute_filter(); + } else { + clear_has_attribute_filter(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ListChannelsOptions.attribute_filter) +} + +// optional string channel_type = 8; +inline bool ListChannelsOptions::has_channel_type() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void ListChannelsOptions::set_has_channel_type() { + _has_bits_[0] |= 0x00000080u; +} +inline void ListChannelsOptions::clear_has_channel_type() { + _has_bits_[0] &= ~0x00000080u; +} +inline void ListChannelsOptions::clear_channel_type() { + if (channel_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + channel_type_->clear(); + } + clear_has_channel_type(); +} +inline const ::std::string& ListChannelsOptions::channel_type() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ListChannelsOptions.channel_type) + return *channel_type_; +} +inline void ListChannelsOptions::set_channel_type(const ::std::string& value) { + set_has_channel_type(); + if (channel_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + channel_type_ = new ::std::string; + } + channel_type_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ListChannelsOptions.channel_type) +} +inline void ListChannelsOptions::set_channel_type(const char* value) { + set_has_channel_type(); + if (channel_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + channel_type_ = new ::std::string; + } + channel_type_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.channel.v1.ListChannelsOptions.channel_type) +} +inline void ListChannelsOptions::set_channel_type(const char* value, size_t size) { + set_has_channel_type(); + if (channel_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + channel_type_ = new ::std::string; + } + channel_type_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.channel.v1.ListChannelsOptions.channel_type) +} +inline ::std::string* ListChannelsOptions::mutable_channel_type() { + set_has_channel_type(); + if (channel_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + channel_type_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ListChannelsOptions.channel_type) + return channel_type_; +} +inline ::std::string* ListChannelsOptions::release_channel_type() { + clear_has_channel_type(); + if (channel_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = channel_type_; + channel_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ListChannelsOptions::set_allocated_channel_type(::std::string* channel_type) { + if (channel_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete channel_type_; + } + if (channel_type) { + set_has_channel_type(); + channel_type_ = channel_type; + } else { + clear_has_channel_type(); + channel_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ListChannelsOptions.channel_type) +} + +// ------------------------------------------------------------------- + +// ChannelDescription + +// required .bgs.protocol.EntityId channel_id = 1; +inline bool ChannelDescription::has_channel_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ChannelDescription::set_has_channel_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void ChannelDescription::clear_has_channel_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ChannelDescription::clear_channel_id() { + if (channel_id_ != NULL) channel_id_->::bgs::protocol::EntityId::Clear(); + clear_has_channel_id(); +} +inline const ::bgs::protocol::EntityId& ChannelDescription::channel_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelDescription.channel_id) + return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_; +} +inline ::bgs::protocol::EntityId* ChannelDescription::mutable_channel_id() { + set_has_channel_id(); + if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelDescription.channel_id) + return channel_id_; +} +inline ::bgs::protocol::EntityId* ChannelDescription::release_channel_id() { + clear_has_channel_id(); + ::bgs::protocol::EntityId* temp = channel_id_; + channel_id_ = NULL; + return temp; +} +inline void ChannelDescription::set_allocated_channel_id(::bgs::protocol::EntityId* channel_id) { + delete channel_id_; + channel_id_ = channel_id; + if (channel_id) { + set_has_channel_id(); + } else { + clear_has_channel_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ChannelDescription.channel_id) +} + +// optional uint32 current_members = 2; +inline bool ChannelDescription::has_current_members() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ChannelDescription::set_has_current_members() { + _has_bits_[0] |= 0x00000002u; +} +inline void ChannelDescription::clear_has_current_members() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ChannelDescription::clear_current_members() { + current_members_ = 0u; + clear_has_current_members(); +} +inline ::google::protobuf::uint32 ChannelDescription::current_members() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelDescription.current_members) + return current_members_; +} +inline void ChannelDescription::set_current_members(::google::protobuf::uint32 value) { + set_has_current_members(); + current_members_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelDescription.current_members) +} + +// optional .bgs.protocol.channel.v1.ChannelState state = 3; +inline bool ChannelDescription::has_state() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ChannelDescription::set_has_state() { + _has_bits_[0] |= 0x00000004u; +} +inline void ChannelDescription::clear_has_state() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ChannelDescription::clear_state() { + if (state_ != NULL) state_->::bgs::protocol::channel::v1::ChannelState::Clear(); + clear_has_state(); +} +inline const ::bgs::protocol::channel::v1::ChannelState& ChannelDescription::state() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelDescription.state) + return state_ != NULL ? *state_ : *default_instance_->state_; +} +inline ::bgs::protocol::channel::v1::ChannelState* ChannelDescription::mutable_state() { + set_has_state(); + if (state_ == NULL) state_ = new ::bgs::protocol::channel::v1::ChannelState; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelDescription.state) + return state_; +} +inline ::bgs::protocol::channel::v1::ChannelState* ChannelDescription::release_state() { + clear_has_state(); + ::bgs::protocol::channel::v1::ChannelState* temp = state_; + state_ = NULL; + return temp; +} +inline void ChannelDescription::set_allocated_state(::bgs::protocol::channel::v1::ChannelState* state) { + delete state_; + state_ = state; + if (state) { + set_has_state(); + } else { + clear_has_state(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ChannelDescription.state) +} + +// ------------------------------------------------------------------- + +// ChannelInfo + +// required .bgs.protocol.channel.v1.ChannelDescription description = 1; +inline bool ChannelInfo::has_description() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ChannelInfo::set_has_description() { + _has_bits_[0] |= 0x00000001u; +} +inline void ChannelInfo::clear_has_description() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ChannelInfo::clear_description() { + if (description_ != NULL) description_->::bgs::protocol::channel::v1::ChannelDescription::Clear(); + clear_has_description(); +} +inline const ::bgs::protocol::channel::v1::ChannelDescription& ChannelInfo::description() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelInfo.description) + return description_ != NULL ? *description_ : *default_instance_->description_; +} +inline ::bgs::protocol::channel::v1::ChannelDescription* ChannelInfo::mutable_description() { + set_has_description(); + if (description_ == NULL) description_ = new ::bgs::protocol::channel::v1::ChannelDescription; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelInfo.description) + return description_; +} +inline ::bgs::protocol::channel::v1::ChannelDescription* ChannelInfo::release_description() { + clear_has_description(); + ::bgs::protocol::channel::v1::ChannelDescription* temp = description_; + description_ = NULL; + return temp; +} +inline void ChannelInfo::set_allocated_description(::bgs::protocol::channel::v1::ChannelDescription* description) { + delete description_; + description_ = description; + if (description) { + set_has_description(); + } else { + clear_has_description(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ChannelInfo.description) +} + +// repeated .bgs.protocol.channel.v1.Member member = 2; +inline int ChannelInfo::member_size() const { + return member_.size(); +} +inline void ChannelInfo::clear_member() { + member_.Clear(); +} +inline const ::bgs::protocol::channel::v1::Member& ChannelInfo::member(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelInfo.member) + return member_.Get(index); +} +inline ::bgs::protocol::channel::v1::Member* ChannelInfo::mutable_member(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelInfo.member) + return member_.Mutable(index); +} +inline ::bgs::protocol::channel::v1::Member* ChannelInfo::add_member() { + // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.ChannelInfo.member) + return member_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >& +ChannelInfo::member() const { + // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.ChannelInfo.member) + return member_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >* +ChannelInfo::mutable_member() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.ChannelInfo.member) + return &member_; +} + +// ------------------------------------------------------------------- + +// ChannelState + +// optional uint32 max_members = 1; +inline bool ChannelState::has_max_members() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ChannelState::set_has_max_members() { + _has_bits_[0] |= 0x00000001u; +} +inline void ChannelState::clear_has_max_members() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ChannelState::clear_max_members() { + max_members_ = 0u; + clear_has_max_members(); +} +inline ::google::protobuf::uint32 ChannelState::max_members() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.max_members) + return max_members_; +} +inline void ChannelState::set_max_members(::google::protobuf::uint32 value) { + set_has_max_members(); + max_members_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.max_members) +} + +// optional uint32 min_members = 2; +inline bool ChannelState::has_min_members() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ChannelState::set_has_min_members() { + _has_bits_[0] |= 0x00000002u; +} +inline void ChannelState::clear_has_min_members() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ChannelState::clear_min_members() { + min_members_ = 0u; + clear_has_min_members(); +} +inline ::google::protobuf::uint32 ChannelState::min_members() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.min_members) + return min_members_; +} +inline void ChannelState::set_min_members(::google::protobuf::uint32 value) { + set_has_min_members(); + min_members_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.min_members) +} + +// repeated .bgs.protocol.Attribute attribute = 3; +inline int ChannelState::attribute_size() const { + return attribute_.size(); +} +inline void ChannelState::clear_attribute() { + attribute_.Clear(); +} +inline const ::bgs::protocol::Attribute& ChannelState::attribute(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.attribute) + return attribute_.Get(index); +} +inline ::bgs::protocol::Attribute* ChannelState::mutable_attribute(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelState.attribute) + return attribute_.Mutable(index); +} +inline ::bgs::protocol::Attribute* ChannelState::add_attribute() { + // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.ChannelState.attribute) + return attribute_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& +ChannelState::attribute() const { + // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.ChannelState.attribute) + return attribute_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* +ChannelState::mutable_attribute() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.ChannelState.attribute) + return &attribute_; +} + +// repeated .bgs.protocol.Invitation invitation = 4; +inline int ChannelState::invitation_size() const { + return invitation_.size(); +} +inline void ChannelState::clear_invitation() { + invitation_.Clear(); +} +inline const ::bgs::protocol::Invitation& ChannelState::invitation(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.invitation) + return invitation_.Get(index); +} +inline ::bgs::protocol::Invitation* ChannelState::mutable_invitation(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelState.invitation) + return invitation_.Mutable(index); +} +inline ::bgs::protocol::Invitation* ChannelState::add_invitation() { + // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.ChannelState.invitation) + return invitation_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >& +ChannelState::invitation() const { + // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.ChannelState.invitation) + return invitation_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >* +ChannelState::mutable_invitation() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.ChannelState.invitation) + return &invitation_; +} + +// optional uint32 max_invitations = 5; +inline bool ChannelState::has_max_invitations() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void ChannelState::set_has_max_invitations() { + _has_bits_[0] |= 0x00000010u; +} +inline void ChannelState::clear_has_max_invitations() { + _has_bits_[0] &= ~0x00000010u; +} +inline void ChannelState::clear_max_invitations() { + max_invitations_ = 0u; + clear_has_max_invitations(); +} +inline ::google::protobuf::uint32 ChannelState::max_invitations() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.max_invitations) + return max_invitations_; +} +inline void ChannelState::set_max_invitations(::google::protobuf::uint32 value) { + set_has_max_invitations(); + max_invitations_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.max_invitations) +} + +// optional uint32 reason = 6; +inline bool ChannelState::has_reason() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void ChannelState::set_has_reason() { + _has_bits_[0] |= 0x00000020u; +} +inline void ChannelState::clear_has_reason() { + _has_bits_[0] &= ~0x00000020u; +} +inline void ChannelState::clear_reason() { + reason_ = 0u; + clear_has_reason(); +} +inline ::google::protobuf::uint32 ChannelState::reason() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.reason) + return reason_; +} +inline void ChannelState::set_reason(::google::protobuf::uint32 value) { + set_has_reason(); + reason_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.reason) +} + +// optional .bgs.protocol.channel.v1.ChannelState.PrivacyLevel privacy_level = 7 [default = PRIVACY_LEVEL_OPEN]; +inline bool ChannelState::has_privacy_level() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void ChannelState::set_has_privacy_level() { + _has_bits_[0] |= 0x00000040u; +} +inline void ChannelState::clear_has_privacy_level() { + _has_bits_[0] &= ~0x00000040u; +} +inline void ChannelState::clear_privacy_level() { + privacy_level_ = 1; + clear_has_privacy_level(); +} +inline ::bgs::protocol::channel::v1::ChannelState_PrivacyLevel ChannelState::privacy_level() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.privacy_level) + return static_cast< ::bgs::protocol::channel::v1::ChannelState_PrivacyLevel >(privacy_level_); +} +inline void ChannelState::set_privacy_level(::bgs::protocol::channel::v1::ChannelState_PrivacyLevel value) { + assert(::bgs::protocol::channel::v1::ChannelState_PrivacyLevel_IsValid(value)); + set_has_privacy_level(); + privacy_level_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.privacy_level) +} + +// optional string name = 8; +inline bool ChannelState::has_name() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void ChannelState::set_has_name() { + _has_bits_[0] |= 0x00000080u; +} +inline void ChannelState::clear_has_name() { + _has_bits_[0] &= ~0x00000080u; +} +inline void ChannelState::clear_name() { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& ChannelState::name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.name) + return *name_; +} +inline void ChannelState::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.name) +} +inline void ChannelState::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.channel.v1.ChannelState.name) +} +inline void ChannelState::set_name(const char* value, size_t size) { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.channel.v1.ChannelState.name) +} +inline ::std::string* ChannelState::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelState.name) + return name_; +} +inline ::std::string* ChannelState::release_name() { + clear_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = name_; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ChannelState::set_allocated_name(::std::string* name) { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete name_; + } + if (name) { + set_has_name(); + name_ = name; + } else { + clear_has_name(); + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ChannelState.name) +} + +// optional string delegate_name = 9; +inline bool ChannelState::has_delegate_name() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void ChannelState::set_has_delegate_name() { + _has_bits_[0] |= 0x00000100u; +} +inline void ChannelState::clear_has_delegate_name() { + _has_bits_[0] &= ~0x00000100u; +} +inline void ChannelState::clear_delegate_name() { + if (delegate_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delegate_name_->clear(); + } + clear_has_delegate_name(); +} +inline const ::std::string& ChannelState::delegate_name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.delegate_name) + return *delegate_name_; +} +inline void ChannelState::set_delegate_name(const ::std::string& value) { + set_has_delegate_name(); + if (delegate_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delegate_name_ = new ::std::string; + } + delegate_name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.delegate_name) +} +inline void ChannelState::set_delegate_name(const char* value) { + set_has_delegate_name(); + if (delegate_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delegate_name_ = new ::std::string; + } + delegate_name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.channel.v1.ChannelState.delegate_name) +} +inline void ChannelState::set_delegate_name(const char* value, size_t size) { + set_has_delegate_name(); + if (delegate_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delegate_name_ = new ::std::string; + } + delegate_name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.channel.v1.ChannelState.delegate_name) +} +inline ::std::string* ChannelState::mutable_delegate_name() { + set_has_delegate_name(); + if (delegate_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delegate_name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelState.delegate_name) + return delegate_name_; +} +inline ::std::string* ChannelState::release_delegate_name() { + clear_has_delegate_name(); + if (delegate_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = delegate_name_; + delegate_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ChannelState::set_allocated_delegate_name(::std::string* delegate_name) { + if (delegate_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete delegate_name_; + } + if (delegate_name) { + set_has_delegate_name(); + delegate_name_ = delegate_name; + } else { + clear_has_delegate_name(); + delegate_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ChannelState.delegate_name) +} + +// optional string channel_type = 10 [default = "default"]; +inline bool ChannelState::has_channel_type() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +inline void ChannelState::set_has_channel_type() { + _has_bits_[0] |= 0x00000200u; +} +inline void ChannelState::clear_has_channel_type() { + _has_bits_[0] &= ~0x00000200u; +} +inline void ChannelState::clear_channel_type() { + if (channel_type_ != _default_channel_type_) { + channel_type_->assign(*_default_channel_type_); + } + clear_has_channel_type(); +} +inline const ::std::string& ChannelState::channel_type() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.channel_type) + return *channel_type_; +} +inline void ChannelState::set_channel_type(const ::std::string& value) { + set_has_channel_type(); + if (channel_type_ == _default_channel_type_) { + channel_type_ = new ::std::string; + } + channel_type_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.channel_type) +} +inline void ChannelState::set_channel_type(const char* value) { + set_has_channel_type(); + if (channel_type_ == _default_channel_type_) { + channel_type_ = new ::std::string; + } + channel_type_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.channel.v1.ChannelState.channel_type) +} +inline void ChannelState::set_channel_type(const char* value, size_t size) { + set_has_channel_type(); + if (channel_type_ == _default_channel_type_) { + channel_type_ = new ::std::string; + } + channel_type_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.channel.v1.ChannelState.channel_type) +} +inline ::std::string* ChannelState::mutable_channel_type() { + set_has_channel_type(); + if (channel_type_ == _default_channel_type_) { + channel_type_ = new ::std::string(*_default_channel_type_); + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelState.channel_type) + return channel_type_; +} +inline ::std::string* ChannelState::release_channel_type() { + clear_has_channel_type(); + if (channel_type_ == _default_channel_type_) { + return NULL; + } else { + ::std::string* temp = channel_type_; + channel_type_ = const_cast< ::std::string*>(_default_channel_type_); + return temp; + } +} +inline void ChannelState::set_allocated_channel_type(::std::string* channel_type) { + if (channel_type_ != _default_channel_type_) { + delete channel_type_; + } + if (channel_type) { + set_has_channel_type(); + channel_type_ = channel_type; + } else { + clear_has_channel_type(); + channel_type_ = const_cast< ::std::string*>(_default_channel_type_); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ChannelState.channel_type) +} + +// optional fixed32 program = 11 [default = 0]; +inline bool ChannelState::has_program() const { + return (_has_bits_[0] & 0x00000400u) != 0; +} +inline void ChannelState::set_has_program() { + _has_bits_[0] |= 0x00000400u; +} +inline void ChannelState::clear_has_program() { + _has_bits_[0] &= ~0x00000400u; +} +inline void ChannelState::clear_program() { + program_ = 0u; + clear_has_program(); +} +inline ::google::protobuf::uint32 ChannelState::program() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.program) + return program_; +} +inline void ChannelState::set_program(::google::protobuf::uint32 value) { + set_has_program(); + program_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.program) +} + +// optional bool allow_offline_members = 12 [default = false]; +inline bool ChannelState::has_allow_offline_members() const { + return (_has_bits_[0] & 0x00000800u) != 0; +} +inline void ChannelState::set_has_allow_offline_members() { + _has_bits_[0] |= 0x00000800u; +} +inline void ChannelState::clear_has_allow_offline_members() { + _has_bits_[0] &= ~0x00000800u; +} +inline void ChannelState::clear_allow_offline_members() { + allow_offline_members_ = false; + clear_has_allow_offline_members(); +} +inline bool ChannelState::allow_offline_members() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.allow_offline_members) + return allow_offline_members_; +} +inline void ChannelState::set_allow_offline_members(bool value) { + set_has_allow_offline_members(); + allow_offline_members_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.allow_offline_members) +} + +// optional bool subscribe_to_presence = 13 [default = true]; +inline bool ChannelState::has_subscribe_to_presence() const { + return (_has_bits_[0] & 0x00001000u) != 0; +} +inline void ChannelState::set_has_subscribe_to_presence() { + _has_bits_[0] |= 0x00001000u; +} +inline void ChannelState::clear_has_subscribe_to_presence() { + _has_bits_[0] &= ~0x00001000u; +} +inline void ChannelState::clear_subscribe_to_presence() { + subscribe_to_presence_ = true; + clear_has_subscribe_to_presence(); +} +inline bool ChannelState::subscribe_to_presence() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.subscribe_to_presence) + return subscribe_to_presence_; +} +inline void ChannelState::set_subscribe_to_presence(bool value) { + set_has_subscribe_to_presence(); + subscribe_to_presence_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.subscribe_to_presence) +} + +// optional bool destroy_on_founder_leave = 14 [default = false]; +inline bool ChannelState::has_destroy_on_founder_leave() const { + return (_has_bits_[0] & 0x00002000u) != 0; +} +inline void ChannelState::set_has_destroy_on_founder_leave() { + _has_bits_[0] |= 0x00002000u; +} +inline void ChannelState::clear_has_destroy_on_founder_leave() { + _has_bits_[0] &= ~0x00002000u; +} +inline void ChannelState::clear_destroy_on_founder_leave() { + destroy_on_founder_leave_ = false; + clear_has_destroy_on_founder_leave(); +} +inline bool ChannelState::destroy_on_founder_leave() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.destroy_on_founder_leave) + return destroy_on_founder_leave_; +} +inline void ChannelState::set_destroy_on_founder_leave(bool value) { + set_has_destroy_on_founder_leave(); + destroy_on_founder_leave_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.destroy_on_founder_leave) +} + +// ------------------------------------------------------------------- + +// MemberState + +// repeated .bgs.protocol.Attribute attribute = 1; +inline int MemberState::attribute_size() const { + return attribute_.size(); +} +inline void MemberState::clear_attribute() { + attribute_.Clear(); +} +inline const ::bgs::protocol::Attribute& MemberState::attribute(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberState.attribute) + return attribute_.Get(index); +} +inline ::bgs::protocol::Attribute* MemberState::mutable_attribute(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberState.attribute) + return attribute_.Mutable(index); +} +inline ::bgs::protocol::Attribute* MemberState::add_attribute() { + // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.MemberState.attribute) + return attribute_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& +MemberState::attribute() const { + // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.MemberState.attribute) + return attribute_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* +MemberState::mutable_attribute() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.MemberState.attribute) + return &attribute_; +} + +// repeated uint32 role = 2 [packed = true]; +inline int MemberState::role_size() const { + return role_.size(); +} +inline void MemberState::clear_role() { + role_.Clear(); +} +inline ::google::protobuf::uint32 MemberState::role(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberState.role) + return role_.Get(index); +} +inline void MemberState::set_role(int index, ::google::protobuf::uint32 value) { + role_.Set(index, value); + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.MemberState.role) +} +inline void MemberState::add_role(::google::protobuf::uint32 value) { + role_.Add(value); + // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.MemberState.role) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +MemberState::role() const { + // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.MemberState.role) + return role_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +MemberState::mutable_role() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.MemberState.role) + return &role_; +} + +// optional uint64 privileges = 3 [default = 0]; +inline bool MemberState::has_privileges() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void MemberState::set_has_privileges() { + _has_bits_[0] |= 0x00000004u; +} +inline void MemberState::clear_has_privileges() { + _has_bits_[0] &= ~0x00000004u; +} +inline void MemberState::clear_privileges() { + privileges_ = GOOGLE_ULONGLONG(0); + clear_has_privileges(); +} +inline ::google::protobuf::uint64 MemberState::privileges() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberState.privileges) + return privileges_; +} +inline void MemberState::set_privileges(::google::protobuf::uint64 value) { + set_has_privileges(); + privileges_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.MemberState.privileges) +} + +// optional .bgs.protocol.AccountInfo info = 4; +inline bool MemberState::has_info() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void MemberState::set_has_info() { + _has_bits_[0] |= 0x00000008u; +} +inline void MemberState::clear_has_info() { + _has_bits_[0] &= ~0x00000008u; +} +inline void MemberState::clear_info() { + if (info_ != NULL) info_->::bgs::protocol::AccountInfo::Clear(); + clear_has_info(); +} +inline const ::bgs::protocol::AccountInfo& MemberState::info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberState.info) + return info_ != NULL ? *info_ : *default_instance_->info_; +} +inline ::bgs::protocol::AccountInfo* MemberState::mutable_info() { + set_has_info(); + if (info_ == NULL) info_ = new ::bgs::protocol::AccountInfo; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberState.info) + return info_; +} +inline ::bgs::protocol::AccountInfo* MemberState::release_info() { + clear_has_info(); + ::bgs::protocol::AccountInfo* temp = info_; + info_ = NULL; + return temp; +} +inline void MemberState::set_allocated_info(::bgs::protocol::AccountInfo* info) { + delete info_; + info_ = info; + if (info) { + set_has_info(); + } else { + clear_has_info(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.MemberState.info) +} + +// optional bool DEPRECATED_hidden = 5 [default = false, deprecated = true]; +inline bool MemberState::has_deprecated_hidden() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void MemberState::set_has_deprecated_hidden() { + _has_bits_[0] |= 0x00000010u; +} +inline void MemberState::clear_has_deprecated_hidden() { + _has_bits_[0] &= ~0x00000010u; +} +inline void MemberState::clear_deprecated_hidden() { + deprecated_hidden_ = false; + clear_has_deprecated_hidden(); +} +inline bool MemberState::deprecated_hidden() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberState.DEPRECATED_hidden) + return deprecated_hidden_; +} +inline void MemberState::set_deprecated_hidden(bool value) { + set_has_deprecated_hidden(); + deprecated_hidden_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.MemberState.DEPRECATED_hidden) +} + +// ------------------------------------------------------------------- + +// Member + +// required .bgs.protocol.Identity identity = 1; +inline bool Member::has_identity() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Member::set_has_identity() { + _has_bits_[0] |= 0x00000001u; +} +inline void Member::clear_has_identity() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Member::clear_identity() { + if (identity_ != NULL) identity_->::bgs::protocol::Identity::Clear(); + clear_has_identity(); +} +inline const ::bgs::protocol::Identity& Member::identity() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.Member.identity) + return identity_ != NULL ? *identity_ : *default_instance_->identity_; +} +inline ::bgs::protocol::Identity* Member::mutable_identity() { + set_has_identity(); + if (identity_ == NULL) identity_ = new ::bgs::protocol::Identity; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.Member.identity) + return identity_; +} +inline ::bgs::protocol::Identity* Member::release_identity() { + clear_has_identity(); + ::bgs::protocol::Identity* temp = identity_; + identity_ = NULL; + return temp; +} +inline void Member::set_allocated_identity(::bgs::protocol::Identity* identity) { + delete identity_; + identity_ = identity; + if (identity) { + set_has_identity(); + } else { + clear_has_identity(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.Member.identity) +} + +// required .bgs.protocol.channel.v1.MemberState state = 2; +inline bool Member::has_state() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Member::set_has_state() { + _has_bits_[0] |= 0x00000002u; +} +inline void Member::clear_has_state() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Member::clear_state() { + if (state_ != NULL) state_->::bgs::protocol::channel::v1::MemberState::Clear(); + clear_has_state(); +} +inline const ::bgs::protocol::channel::v1::MemberState& Member::state() const { + // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.Member.state) + return state_ != NULL ? *state_ : *default_instance_->state_; +} +inline ::bgs::protocol::channel::v1::MemberState* Member::mutable_state() { + set_has_state(); + if (state_ == NULL) state_ = new ::bgs::protocol::channel::v1::MemberState; + // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.Member.state) + return state_; +} +inline ::bgs::protocol::channel::v1::MemberState* Member::release_state() { + clear_has_state(); + ::bgs::protocol::channel::v1::MemberState* temp = state_; + state_ = NULL; + return temp; +} +inline void Member::set_allocated_state(::bgs::protocol::channel::v1::MemberState* state) { + delete state_; + state_ = state; + if (state) { + set_has_state(); + } else { + clear_has_state(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.Member.state) +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace channel +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + +template <> struct is_proto_enum< ::bgs::protocol::channel::v1::ChannelState_PrivacyLevel> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::channel::v1::ChannelState_PrivacyLevel>() { + return ::bgs::protocol::channel::v1::ChannelState_PrivacyLevel_descriptor(); +} + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_channel_5ftypes_2eproto__INCLUDED diff --git a/src/server/proto/Client/connection_service.pb.cc b/src/server/proto/Client/connection_service.pb.cc new file mode 100644 index 00000000000..97a3d5275bc --- /dev/null +++ b/src/server/proto/Client/connection_service.pb.cc @@ -0,0 +1,3876 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: connection_service.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "connection_service.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +#include "BattlenetRpcErrorCodes.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { +namespace connection { +namespace v1 { + +namespace { + +const ::google::protobuf::Descriptor* ConnectRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ConnectRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* ConnectionMeteringContentHandles_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ConnectionMeteringContentHandles_reflection_ = NULL; +const ::google::protobuf::Descriptor* ConnectResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ConnectResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* BoundService_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + BoundService_reflection_ = NULL; +const ::google::protobuf::Descriptor* BindRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + BindRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* BindResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + BindResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* EchoRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + EchoRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* EchoResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + EchoResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* DisconnectRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + DisconnectRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* DisconnectNotification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + DisconnectNotification_reflection_ = NULL; +const ::google::protobuf::Descriptor* EncryptRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + EncryptRequest_reflection_ = NULL; +const ::google::protobuf::ServiceDescriptor* ConnectionService_descriptor_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_connection_5fservice_2eproto() { + protobuf_AddDesc_connection_5fservice_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "connection_service.proto"); + GOOGLE_CHECK(file != NULL); + ConnectRequest_descriptor_ = file->message_type(0); + static const int ConnectRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectRequest, client_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectRequest, bind_request_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectRequest, use_bindless_rpc_), + }; + ConnectRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ConnectRequest_descriptor_, + ConnectRequest::default_instance_, + ConnectRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ConnectRequest)); + ConnectionMeteringContentHandles_descriptor_ = file->message_type(1); + static const int ConnectionMeteringContentHandles_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectionMeteringContentHandles, content_handle_), + }; + ConnectionMeteringContentHandles_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ConnectionMeteringContentHandles_descriptor_, + ConnectionMeteringContentHandles::default_instance_, + ConnectionMeteringContentHandles_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectionMeteringContentHandles, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectionMeteringContentHandles, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ConnectionMeteringContentHandles)); + ConnectResponse_descriptor_ = file->message_type(2); + static const int ConnectResponse_offsets_[8] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectResponse, server_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectResponse, client_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectResponse, bind_result_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectResponse, bind_response_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectResponse, content_handle_array_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectResponse, server_time_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectResponse, use_bindless_rpc_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectResponse, binary_content_handle_array_), + }; + ConnectResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ConnectResponse_descriptor_, + ConnectResponse::default_instance_, + ConnectResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ConnectResponse)); + BoundService_descriptor_ = file->message_type(3); + static const int BoundService_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BoundService, hash_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BoundService, id_), + }; + BoundService_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + BoundService_descriptor_, + BoundService::default_instance_, + BoundService_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BoundService, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BoundService, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(BoundService)); + BindRequest_descriptor_ = file->message_type(4); + static const int BindRequest_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BindRequest, deprecated_imported_service_hash_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BindRequest, deprecated_exported_service_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BindRequest, exported_service_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BindRequest, imported_service_), + }; + BindRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + BindRequest_descriptor_, + BindRequest::default_instance_, + BindRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BindRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BindRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(BindRequest)); + BindResponse_descriptor_ = file->message_type(5); + static const int BindResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BindResponse, imported_service_id_), + }; + BindResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + BindResponse_descriptor_, + BindResponse::default_instance_, + BindResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BindResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BindResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(BindResponse)); + EchoRequest_descriptor_ = file->message_type(6); + static const int EchoRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EchoRequest, time_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EchoRequest, network_only_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EchoRequest, payload_), + }; + EchoRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + EchoRequest_descriptor_, + EchoRequest::default_instance_, + EchoRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EchoRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EchoRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(EchoRequest)); + EchoResponse_descriptor_ = file->message_type(7); + static const int EchoResponse_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EchoResponse, time_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EchoResponse, payload_), + }; + EchoResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + EchoResponse_descriptor_, + EchoResponse::default_instance_, + EchoResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EchoResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EchoResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(EchoResponse)); + DisconnectRequest_descriptor_ = file->message_type(8); + static const int DisconnectRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DisconnectRequest, error_code_), + }; + DisconnectRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + DisconnectRequest_descriptor_, + DisconnectRequest::default_instance_, + DisconnectRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DisconnectRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DisconnectRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(DisconnectRequest)); + DisconnectNotification_descriptor_ = file->message_type(9); + static const int DisconnectNotification_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DisconnectNotification, error_code_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DisconnectNotification, reason_), + }; + DisconnectNotification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + DisconnectNotification_descriptor_, + DisconnectNotification::default_instance_, + DisconnectNotification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DisconnectNotification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DisconnectNotification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(DisconnectNotification)); + EncryptRequest_descriptor_ = file->message_type(10); + static const int EncryptRequest_offsets_[1] = { + }; + EncryptRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + EncryptRequest_descriptor_, + EncryptRequest::default_instance_, + EncryptRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EncryptRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EncryptRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(EncryptRequest)); + ConnectionService_descriptor_ = file->service(0); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_connection_5fservice_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ConnectRequest_descriptor_, &ConnectRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ConnectionMeteringContentHandles_descriptor_, &ConnectionMeteringContentHandles::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ConnectResponse_descriptor_, &ConnectResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + BoundService_descriptor_, &BoundService::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + BindRequest_descriptor_, &BindRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + BindResponse_descriptor_, &BindResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + EchoRequest_descriptor_, &EchoRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + EchoResponse_descriptor_, &EchoResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + DisconnectRequest_descriptor_, &DisconnectRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + DisconnectNotification_descriptor_, &DisconnectNotification::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + EncryptRequest_descriptor_, &EncryptRequest::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_connection_5fservice_2eproto() { + delete ConnectRequest::default_instance_; + delete ConnectRequest_reflection_; + delete ConnectionMeteringContentHandles::default_instance_; + delete ConnectionMeteringContentHandles_reflection_; + delete ConnectResponse::default_instance_; + delete ConnectResponse_reflection_; + delete BoundService::default_instance_; + delete BoundService_reflection_; + delete BindRequest::default_instance_; + delete BindRequest_reflection_; + delete BindResponse::default_instance_; + delete BindResponse_reflection_; + delete EchoRequest::default_instance_; + delete EchoRequest_reflection_; + delete EchoResponse::default_instance_; + delete EchoResponse_reflection_; + delete DisconnectRequest::default_instance_; + delete DisconnectRequest_reflection_; + delete DisconnectNotification::default_instance_; + delete DisconnectNotification_reflection_; + delete EncryptRequest::default_instance_; + delete EncryptRequest_reflection_; +} + +void protobuf_AddDesc_connection_5fservice_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::bgs::protocol::protobuf_AddDesc_content_5fhandle_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\030connection_service.proto\022\032bgs.protocol" + ".connection.v1\032\032content_handle_types.pro" + "to\032\017rpc_types.proto\"\233\001\n\016ConnectRequest\022*" + "\n\tclient_id\030\001 \001(\0132\027.bgs.protocol.Process" + "Id\022=\n\014bind_request\030\002 \001(\0132\'.bgs.protocol." + "connection.v1.BindRequest\022\036\n\020use_bindles" + "s_rpc\030\003 \001(\010:\004true\"W\n ConnectionMeteringC" + "ontentHandles\0223\n\016content_handle\030\001 \003(\0132\033." + "bgs.protocol.ContentHandle\"\264\003\n\017ConnectRe" + "sponse\022*\n\tserver_id\030\001 \002(\0132\027.bgs.protocol" + ".ProcessId\022*\n\tclient_id\030\002 \001(\0132\027.bgs.prot" + "ocol.ProcessId\022\023\n\013bind_result\030\003 \001(\r\022\?\n\rb" + "ind_response\030\004 \001(\0132(.bgs.protocol.connec" + "tion.v1.BindResponse\022Z\n\024content_handle_a" + "rray\030\005 \001(\0132<.bgs.protocol.connection.v1." + "ConnectionMeteringContentHandles\022\023\n\013serv" + "er_time\030\006 \001(\004\022\037\n\020use_bindless_rpc\030\007 \001(\010:" + "\005false\022a\n\033binary_content_handle_array\030\010 " + "\001(\0132<.bgs.protocol.connection.v1.Connect" + "ionMeteringContentHandles\"(\n\014BoundServic" + "e\022\014\n\004hash\030\001 \002(\007\022\n\n\002id\030\002 \002(\r\"\230\002\n\013BindRequ" + "est\022.\n deprecated_imported_service_hash\030" + "\001 \003(\007B\004\020\001\030\001\022Q\n\033deprecated_exported_servi" + "ce\030\002 \003(\0132(.bgs.protocol.connection.v1.Bo" + "undServiceB\002\030\001\022B\n\020exported_service\030\003 \003(\013" + "2(.bgs.protocol.connection.v1.BoundServi" + "ce\022B\n\020imported_service\030\004 \003(\0132(.bgs.proto" + "col.connection.v1.BoundService\"1\n\014BindRe" + "sponse\022!\n\023imported_service_id\030\001 \003(\rB\004\020\001\030" + "\001\"I\n\013EchoRequest\022\014\n\004time\030\001 \001(\006\022\033\n\014networ" + "k_only\030\002 \001(\010:\005false\022\017\n\007payload\030\003 \001(\014\"-\n\014" + "EchoResponse\022\014\n\004time\030\001 \001(\006\022\017\n\007payload\030\002 " + "\001(\014\"\'\n\021DisconnectRequest\022\022\n\nerror_code\030\001" + " \002(\r\"<\n\026DisconnectNotification\022\022\n\nerror_" + "code\030\001 \002(\r\022\016\n\006reason\030\002 \001(\t\"\020\n\016EncryptReq" + "uest2\330\005\n\021ConnectionService\022h\n\007Connect\022*." + "bgs.protocol.connection.v1.ConnectReques" + "t\032+.bgs.protocol.connection.v1.ConnectRe" + "sponse\"\004\200\265\030\001\022b\n\004Bind\022\'.bgs.protocol.conn" + "ection.v1.BindRequest\032(.bgs.protocol.con" + "nection.v1.BindResponse\"\007\210\002\001\200\265\030\002\022_\n\004Echo" + "\022\'.bgs.protocol.connection.v1.EchoReques" + "t\032(.bgs.protocol.connection.v1.EchoRespo" + "nse\"\004\200\265\030\003\022f\n\017ForceDisconnect\0222.bgs.proto" + "col.connection.v1.DisconnectNotification" + "\032\031.bgs.protocol.NO_RESPONSE\"\004\200\265\030\004\022B\n\tKee" + "pAlive\022\024.bgs.protocol.NoData\032\031.bgs.proto" + "col.NO_RESPONSE\"\004\200\265\030\005\022T\n\007Encrypt\022*.bgs.p" + "rotocol.connection.v1.EncryptRequest\032\024.b" + "gs.protocol.NoData\"\007\210\002\001\200\265\030\006\022c\n\021RequestDi" + "sconnect\022-.bgs.protocol.connection.v1.Di" + "sconnectRequest\032\031.bgs.protocol.NO_RESPON" + "SE\"\004\200\265\030\007\032-\312>*bnet.protocol.connection.Co" + "nnectionServiceB=\n\033bnet.protocol.connect" + "ion.v1B\026ConnectionServiceProtoH\001\200\001\000\210\001\001", 2198); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "connection_service.proto", &protobuf_RegisterTypes); + ConnectRequest::default_instance_ = new ConnectRequest(); + ConnectionMeteringContentHandles::default_instance_ = new ConnectionMeteringContentHandles(); + ConnectResponse::default_instance_ = new ConnectResponse(); + BoundService::default_instance_ = new BoundService(); + BindRequest::default_instance_ = new BindRequest(); + BindResponse::default_instance_ = new BindResponse(); + EchoRequest::default_instance_ = new EchoRequest(); + EchoResponse::default_instance_ = new EchoResponse(); + DisconnectRequest::default_instance_ = new DisconnectRequest(); + DisconnectNotification::default_instance_ = new DisconnectNotification(); + EncryptRequest::default_instance_ = new EncryptRequest(); + ConnectRequest::default_instance_->InitAsDefaultInstance(); + ConnectionMeteringContentHandles::default_instance_->InitAsDefaultInstance(); + ConnectResponse::default_instance_->InitAsDefaultInstance(); + BoundService::default_instance_->InitAsDefaultInstance(); + BindRequest::default_instance_->InitAsDefaultInstance(); + BindResponse::default_instance_->InitAsDefaultInstance(); + EchoRequest::default_instance_->InitAsDefaultInstance(); + EchoResponse::default_instance_->InitAsDefaultInstance(); + DisconnectRequest::default_instance_->InitAsDefaultInstance(); + DisconnectNotification::default_instance_->InitAsDefaultInstance(); + EncryptRequest::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_connection_5fservice_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_connection_5fservice_2eproto { + StaticDescriptorInitializer_connection_5fservice_2eproto() { + protobuf_AddDesc_connection_5fservice_2eproto(); + } +} static_descriptor_initializer_connection_5fservice_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int ConnectRequest::kClientIdFieldNumber; +const int ConnectRequest::kBindRequestFieldNumber; +const int ConnectRequest::kUseBindlessRpcFieldNumber; +#endif // !_MSC_VER + +ConnectRequest::ConnectRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.connection.v1.ConnectRequest) +} + +void ConnectRequest::InitAsDefaultInstance() { + client_id_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance()); + bind_request_ = const_cast< ::bgs::protocol::connection::v1::BindRequest*>(&::bgs::protocol::connection::v1::BindRequest::default_instance()); +} + +ConnectRequest::ConnectRequest(const ConnectRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.connection.v1.ConnectRequest) +} + +void ConnectRequest::SharedCtor() { + _cached_size_ = 0; + client_id_ = NULL; + bind_request_ = NULL; + use_bindless_rpc_ = true; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ConnectRequest::~ConnectRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.connection.v1.ConnectRequest) + SharedDtor(); +} + +void ConnectRequest::SharedDtor() { + if (this != default_instance_) { + delete client_id_; + delete bind_request_; + } +} + +void ConnectRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ConnectRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ConnectRequest_descriptor_; +} + +const ConnectRequest& ConnectRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_connection_5fservice_2eproto(); + return *default_instance_; +} + +ConnectRequest* ConnectRequest::default_instance_ = NULL; + +ConnectRequest* ConnectRequest::New() const { + return new ConnectRequest; +} + +void ConnectRequest::Clear() { + if (_has_bits_[0 / 32] & 7) { + if (has_client_id()) { + if (client_id_ != NULL) client_id_->::bgs::protocol::ProcessId::Clear(); + } + if (has_bind_request()) { + if (bind_request_ != NULL) bind_request_->::bgs::protocol::connection::v1::BindRequest::Clear(); + } + use_bindless_rpc_ = true; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ConnectRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.connection.v1.ConnectRequest) + 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 .bgs.protocol.ProcessId client_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_client_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_bind_request; + break; + } + + // optional .bgs.protocol.connection.v1.BindRequest bind_request = 2; + case 2: { + if (tag == 18) { + parse_bind_request: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_bind_request())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_use_bindless_rpc; + break; + } + + // optional bool use_bindless_rpc = 3 [default = true]; + case 3: { + if (tag == 24) { + parse_use_bindless_rpc: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &use_bindless_rpc_))); + set_has_use_bindless_rpc(); + } 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:bgs.protocol.connection.v1.ConnectRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.connection.v1.ConnectRequest) + return false; +#undef DO_ +} + +void ConnectRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.connection.v1.ConnectRequest) + // optional .bgs.protocol.ProcessId client_id = 1; + if (has_client_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->client_id(), output); + } + + // optional .bgs.protocol.connection.v1.BindRequest bind_request = 2; + if (has_bind_request()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->bind_request(), output); + } + + // optional bool use_bindless_rpc = 3 [default = true]; + if (has_use_bindless_rpc()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->use_bindless_rpc(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.connection.v1.ConnectRequest) +} + +::google::protobuf::uint8* ConnectRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.connection.v1.ConnectRequest) + // optional .bgs.protocol.ProcessId client_id = 1; + if (has_client_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->client_id(), target); + } + + // optional .bgs.protocol.connection.v1.BindRequest bind_request = 2; + if (has_bind_request()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->bind_request(), target); + } + + // optional bool use_bindless_rpc = 3 [default = true]; + if (has_use_bindless_rpc()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->use_bindless_rpc(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.connection.v1.ConnectRequest) + return target; +} + +int ConnectRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.ProcessId client_id = 1; + if (has_client_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->client_id()); + } + + // optional .bgs.protocol.connection.v1.BindRequest bind_request = 2; + if (has_bind_request()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->bind_request()); + } + + // optional bool use_bindless_rpc = 3 [default = true]; + if (has_use_bindless_rpc()) { + 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 ConnectRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ConnectRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ConnectRequest::MergeFrom(const ConnectRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_client_id()) { + mutable_client_id()->::bgs::protocol::ProcessId::MergeFrom(from.client_id()); + } + if (from.has_bind_request()) { + mutable_bind_request()->::bgs::protocol::connection::v1::BindRequest::MergeFrom(from.bind_request()); + } + if (from.has_use_bindless_rpc()) { + set_use_bindless_rpc(from.use_bindless_rpc()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ConnectRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ConnectRequest::CopyFrom(const ConnectRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ConnectRequest::IsInitialized() const { + + if (has_client_id()) { + if (!this->client_id().IsInitialized()) return false; + } + if (has_bind_request()) { + if (!this->bind_request().IsInitialized()) return false; + } + return true; +} + +void ConnectRequest::Swap(ConnectRequest* other) { + if (other != this) { + std::swap(client_id_, other->client_id_); + std::swap(bind_request_, other->bind_request_); + std::swap(use_bindless_rpc_, other->use_bindless_rpc_); + 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 ConnectRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ConnectRequest_descriptor_; + metadata.reflection = ConnectRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ConnectionMeteringContentHandles::kContentHandleFieldNumber; +#endif // !_MSC_VER + +ConnectionMeteringContentHandles::ConnectionMeteringContentHandles() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.connection.v1.ConnectionMeteringContentHandles) +} + +void ConnectionMeteringContentHandles::InitAsDefaultInstance() { +} + +ConnectionMeteringContentHandles::ConnectionMeteringContentHandles(const ConnectionMeteringContentHandles& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.connection.v1.ConnectionMeteringContentHandles) +} + +void ConnectionMeteringContentHandles::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ConnectionMeteringContentHandles::~ConnectionMeteringContentHandles() { + // @@protoc_insertion_point(destructor:bgs.protocol.connection.v1.ConnectionMeteringContentHandles) + SharedDtor(); +} + +void ConnectionMeteringContentHandles::SharedDtor() { + if (this != default_instance_) { + } +} + +void ConnectionMeteringContentHandles::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ConnectionMeteringContentHandles::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ConnectionMeteringContentHandles_descriptor_; +} + +const ConnectionMeteringContentHandles& ConnectionMeteringContentHandles::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_connection_5fservice_2eproto(); + return *default_instance_; +} + +ConnectionMeteringContentHandles* ConnectionMeteringContentHandles::default_instance_ = NULL; + +ConnectionMeteringContentHandles* ConnectionMeteringContentHandles::New() const { + return new ConnectionMeteringContentHandles; +} + +void ConnectionMeteringContentHandles::Clear() { + content_handle_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ConnectionMeteringContentHandles::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.connection.v1.ConnectionMeteringContentHandles) + 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 .bgs.protocol.ContentHandle content_handle = 1; + case 1: { + if (tag == 10) { + parse_content_handle: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_content_handle())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_content_handle; + 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:bgs.protocol.connection.v1.ConnectionMeteringContentHandles) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.connection.v1.ConnectionMeteringContentHandles) + return false; +#undef DO_ +} + +void ConnectionMeteringContentHandles::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.connection.v1.ConnectionMeteringContentHandles) + // repeated .bgs.protocol.ContentHandle content_handle = 1; + for (int i = 0; i < this->content_handle_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->content_handle(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.connection.v1.ConnectionMeteringContentHandles) +} + +::google::protobuf::uint8* ConnectionMeteringContentHandles::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.connection.v1.ConnectionMeteringContentHandles) + // repeated .bgs.protocol.ContentHandle content_handle = 1; + for (int i = 0; i < this->content_handle_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->content_handle(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.connection.v1.ConnectionMeteringContentHandles) + return target; +} + +int ConnectionMeteringContentHandles::ByteSize() const { + int total_size = 0; + + // repeated .bgs.protocol.ContentHandle content_handle = 1; + total_size += 1 * this->content_handle_size(); + for (int i = 0; i < this->content_handle_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->content_handle(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 ConnectionMeteringContentHandles::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ConnectionMeteringContentHandles* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ConnectionMeteringContentHandles::MergeFrom(const ConnectionMeteringContentHandles& from) { + GOOGLE_CHECK_NE(&from, this); + content_handle_.MergeFrom(from.content_handle_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ConnectionMeteringContentHandles::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ConnectionMeteringContentHandles::CopyFrom(const ConnectionMeteringContentHandles& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ConnectionMeteringContentHandles::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->content_handle())) return false; + return true; +} + +void ConnectionMeteringContentHandles::Swap(ConnectionMeteringContentHandles* other) { + if (other != this) { + content_handle_.Swap(&other->content_handle_); + 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 ConnectionMeteringContentHandles::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ConnectionMeteringContentHandles_descriptor_; + metadata.reflection = ConnectionMeteringContentHandles_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ConnectResponse::kServerIdFieldNumber; +const int ConnectResponse::kClientIdFieldNumber; +const int ConnectResponse::kBindResultFieldNumber; +const int ConnectResponse::kBindResponseFieldNumber; +const int ConnectResponse::kContentHandleArrayFieldNumber; +const int ConnectResponse::kServerTimeFieldNumber; +const int ConnectResponse::kUseBindlessRpcFieldNumber; +const int ConnectResponse::kBinaryContentHandleArrayFieldNumber; +#endif // !_MSC_VER + +ConnectResponse::ConnectResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.connection.v1.ConnectResponse) +} + +void ConnectResponse::InitAsDefaultInstance() { + server_id_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance()); + client_id_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance()); + bind_response_ = const_cast< ::bgs::protocol::connection::v1::BindResponse*>(&::bgs::protocol::connection::v1::BindResponse::default_instance()); + content_handle_array_ = const_cast< ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles*>(&::bgs::protocol::connection::v1::ConnectionMeteringContentHandles::default_instance()); + binary_content_handle_array_ = const_cast< ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles*>(&::bgs::protocol::connection::v1::ConnectionMeteringContentHandles::default_instance()); +} + +ConnectResponse::ConnectResponse(const ConnectResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.connection.v1.ConnectResponse) +} + +void ConnectResponse::SharedCtor() { + _cached_size_ = 0; + server_id_ = NULL; + client_id_ = NULL; + bind_result_ = 0u; + bind_response_ = NULL; + content_handle_array_ = NULL; + server_time_ = GOOGLE_ULONGLONG(0); + use_bindless_rpc_ = false; + binary_content_handle_array_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ConnectResponse::~ConnectResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.connection.v1.ConnectResponse) + SharedDtor(); +} + +void ConnectResponse::SharedDtor() { + if (this != default_instance_) { + delete server_id_; + delete client_id_; + delete bind_response_; + delete content_handle_array_; + delete binary_content_handle_array_; + } +} + +void ConnectResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ConnectResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ConnectResponse_descriptor_; +} + +const ConnectResponse& ConnectResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_connection_5fservice_2eproto(); + return *default_instance_; +} + +ConnectResponse* ConnectResponse::default_instance_ = NULL; + +ConnectResponse* ConnectResponse::New() const { + return new ConnectResponse; +} + +void ConnectResponse::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(bind_result_, server_time_); + if (has_server_id()) { + if (server_id_ != NULL) server_id_->::bgs::protocol::ProcessId::Clear(); + } + if (has_client_id()) { + if (client_id_ != NULL) client_id_->::bgs::protocol::ProcessId::Clear(); + } + if (has_bind_response()) { + if (bind_response_ != NULL) bind_response_->::bgs::protocol::connection::v1::BindResponse::Clear(); + } + if (has_content_handle_array()) { + if (content_handle_array_ != NULL) content_handle_array_->::bgs::protocol::connection::v1::ConnectionMeteringContentHandles::Clear(); + } + if (has_binary_content_handle_array()) { + if (binary_content_handle_array_ != NULL) binary_content_handle_array_->::bgs::protocol::connection::v1::ConnectionMeteringContentHandles::Clear(); + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ConnectResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.connection.v1.ConnectResponse) + 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)) { + // required .bgs.protocol.ProcessId server_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_server_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_client_id; + break; + } + + // optional .bgs.protocol.ProcessId client_id = 2; + case 2: { + if (tag == 18) { + parse_client_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_client_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_bind_result; + break; + } + + // optional uint32 bind_result = 3; + case 3: { + if (tag == 24) { + parse_bind_result: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &bind_result_))); + set_has_bind_result(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_bind_response; + break; + } + + // optional .bgs.protocol.connection.v1.BindResponse bind_response = 4; + case 4: { + if (tag == 34) { + parse_bind_response: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_bind_response())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_content_handle_array; + break; + } + + // optional .bgs.protocol.connection.v1.ConnectionMeteringContentHandles content_handle_array = 5; + case 5: { + if (tag == 42) { + parse_content_handle_array: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_content_handle_array())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_server_time; + break; + } + + // optional uint64 server_time = 6; + case 6: { + if (tag == 48) { + parse_server_time: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &server_time_))); + set_has_server_time(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(56)) goto parse_use_bindless_rpc; + break; + } + + // optional bool use_bindless_rpc = 7 [default = false]; + case 7: { + if (tag == 56) { + parse_use_bindless_rpc: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &use_bindless_rpc_))); + set_has_use_bindless_rpc(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(66)) goto parse_binary_content_handle_array; + break; + } + + // optional .bgs.protocol.connection.v1.ConnectionMeteringContentHandles binary_content_handle_array = 8; + case 8: { + if (tag == 66) { + parse_binary_content_handle_array: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_binary_content_handle_array())); + } 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:bgs.protocol.connection.v1.ConnectResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.connection.v1.ConnectResponse) + return false; +#undef DO_ +} + +void ConnectResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.connection.v1.ConnectResponse) + // required .bgs.protocol.ProcessId server_id = 1; + if (has_server_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->server_id(), output); + } + + // optional .bgs.protocol.ProcessId client_id = 2; + if (has_client_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->client_id(), output); + } + + // optional uint32 bind_result = 3; + if (has_bind_result()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->bind_result(), output); + } + + // optional .bgs.protocol.connection.v1.BindResponse bind_response = 4; + if (has_bind_response()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->bind_response(), output); + } + + // optional .bgs.protocol.connection.v1.ConnectionMeteringContentHandles content_handle_array = 5; + if (has_content_handle_array()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, this->content_handle_array(), output); + } + + // optional uint64 server_time = 6; + if (has_server_time()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(6, this->server_time(), output); + } + + // optional bool use_bindless_rpc = 7 [default = false]; + if (has_use_bindless_rpc()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->use_bindless_rpc(), output); + } + + // optional .bgs.protocol.connection.v1.ConnectionMeteringContentHandles binary_content_handle_array = 8; + if (has_binary_content_handle_array()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 8, this->binary_content_handle_array(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.connection.v1.ConnectResponse) +} + +::google::protobuf::uint8* ConnectResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.connection.v1.ConnectResponse) + // required .bgs.protocol.ProcessId server_id = 1; + if (has_server_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->server_id(), target); + } + + // optional .bgs.protocol.ProcessId client_id = 2; + if (has_client_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->client_id(), target); + } + + // optional uint32 bind_result = 3; + if (has_bind_result()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->bind_result(), target); + } + + // optional .bgs.protocol.connection.v1.BindResponse bind_response = 4; + if (has_bind_response()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->bind_response(), target); + } + + // optional .bgs.protocol.connection.v1.ConnectionMeteringContentHandles content_handle_array = 5; + if (has_content_handle_array()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 5, this->content_handle_array(), target); + } + + // optional uint64 server_time = 6; + if (has_server_time()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(6, this->server_time(), target); + } + + // optional bool use_bindless_rpc = 7 [default = false]; + if (has_use_bindless_rpc()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->use_bindless_rpc(), target); + } + + // optional .bgs.protocol.connection.v1.ConnectionMeteringContentHandles binary_content_handle_array = 8; + if (has_binary_content_handle_array()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 8, this->binary_content_handle_array(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.connection.v1.ConnectResponse) + return target; +} + +int ConnectResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.ProcessId server_id = 1; + if (has_server_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->server_id()); + } + + // optional .bgs.protocol.ProcessId client_id = 2; + if (has_client_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->client_id()); + } + + // optional uint32 bind_result = 3; + if (has_bind_result()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->bind_result()); + } + + // optional .bgs.protocol.connection.v1.BindResponse bind_response = 4; + if (has_bind_response()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->bind_response()); + } + + // optional .bgs.protocol.connection.v1.ConnectionMeteringContentHandles content_handle_array = 5; + if (has_content_handle_array()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->content_handle_array()); + } + + // optional uint64 server_time = 6; + if (has_server_time()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->server_time()); + } + + // optional bool use_bindless_rpc = 7 [default = false]; + if (has_use_bindless_rpc()) { + total_size += 1 + 1; + } + + // optional .bgs.protocol.connection.v1.ConnectionMeteringContentHandles binary_content_handle_array = 8; + if (has_binary_content_handle_array()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->binary_content_handle_array()); + } + + } + 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 ConnectResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ConnectResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ConnectResponse::MergeFrom(const ConnectResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_server_id()) { + mutable_server_id()->::bgs::protocol::ProcessId::MergeFrom(from.server_id()); + } + if (from.has_client_id()) { + mutable_client_id()->::bgs::protocol::ProcessId::MergeFrom(from.client_id()); + } + if (from.has_bind_result()) { + set_bind_result(from.bind_result()); + } + if (from.has_bind_response()) { + mutable_bind_response()->::bgs::protocol::connection::v1::BindResponse::MergeFrom(from.bind_response()); + } + if (from.has_content_handle_array()) { + mutable_content_handle_array()->::bgs::protocol::connection::v1::ConnectionMeteringContentHandles::MergeFrom(from.content_handle_array()); + } + if (from.has_server_time()) { + set_server_time(from.server_time()); + } + if (from.has_use_bindless_rpc()) { + set_use_bindless_rpc(from.use_bindless_rpc()); + } + if (from.has_binary_content_handle_array()) { + mutable_binary_content_handle_array()->::bgs::protocol::connection::v1::ConnectionMeteringContentHandles::MergeFrom(from.binary_content_handle_array()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ConnectResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ConnectResponse::CopyFrom(const ConnectResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ConnectResponse::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_server_id()) { + if (!this->server_id().IsInitialized()) return false; + } + if (has_client_id()) { + if (!this->client_id().IsInitialized()) return false; + } + if (has_content_handle_array()) { + if (!this->content_handle_array().IsInitialized()) return false; + } + if (has_binary_content_handle_array()) { + if (!this->binary_content_handle_array().IsInitialized()) return false; + } + return true; +} + +void ConnectResponse::Swap(ConnectResponse* other) { + if (other != this) { + std::swap(server_id_, other->server_id_); + std::swap(client_id_, other->client_id_); + std::swap(bind_result_, other->bind_result_); + std::swap(bind_response_, other->bind_response_); + std::swap(content_handle_array_, other->content_handle_array_); + std::swap(server_time_, other->server_time_); + std::swap(use_bindless_rpc_, other->use_bindless_rpc_); + std::swap(binary_content_handle_array_, other->binary_content_handle_array_); + 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 ConnectResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ConnectResponse_descriptor_; + metadata.reflection = ConnectResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int BoundService::kHashFieldNumber; +const int BoundService::kIdFieldNumber; +#endif // !_MSC_VER + +BoundService::BoundService() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.connection.v1.BoundService) +} + +void BoundService::InitAsDefaultInstance() { +} + +BoundService::BoundService(const BoundService& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.connection.v1.BoundService) +} + +void BoundService::SharedCtor() { + _cached_size_ = 0; + hash_ = 0u; + id_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +BoundService::~BoundService() { + // @@protoc_insertion_point(destructor:bgs.protocol.connection.v1.BoundService) + SharedDtor(); +} + +void BoundService::SharedDtor() { + if (this != default_instance_) { + } +} + +void BoundService::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* BoundService::descriptor() { + protobuf_AssignDescriptorsOnce(); + return BoundService_descriptor_; +} + +const BoundService& BoundService::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_connection_5fservice_2eproto(); + return *default_instance_; +} + +BoundService* BoundService::default_instance_ = NULL; + +BoundService* BoundService::New() const { + return new BoundService; +} + +void BoundService::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(hash_, id_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool BoundService::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.connection.v1.BoundService) + 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)) { + // required fixed32 hash = 1; + case 1: { + if (tag == 13) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &hash_))); + set_has_hash(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_id; + break; + } + + // required uint32 id = 2; + case 2: { + if (tag == 16) { + parse_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &id_))); + set_has_id(); + } 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:bgs.protocol.connection.v1.BoundService) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.connection.v1.BoundService) + return false; +#undef DO_ +} + +void BoundService::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.connection.v1.BoundService) + // required fixed32 hash = 1; + if (has_hash()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->hash(), output); + } + + // required uint32 id = 2; + if (has_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.connection.v1.BoundService) +} + +::google::protobuf::uint8* BoundService::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.connection.v1.BoundService) + // required fixed32 hash = 1; + if (has_hash()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->hash(), target); + } + + // required uint32 id = 2; + if (has_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.connection.v1.BoundService) + return target; +} + +int BoundService::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed32 hash = 1; + if (has_hash()) { + total_size += 1 + 4; + } + + // required uint32 id = 2; + if (has_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void BoundService::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const BoundService* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void BoundService::MergeFrom(const BoundService& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_hash()) { + set_hash(from.hash()); + } + if (from.has_id()) { + set_id(from.id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void BoundService::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void BoundService::CopyFrom(const BoundService& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BoundService::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void BoundService::Swap(BoundService* other) { + if (other != this) { + std::swap(hash_, other->hash_); + std::swap(id_, other->id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata BoundService::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = BoundService_descriptor_; + metadata.reflection = BoundService_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int BindRequest::kDeprecatedImportedServiceHashFieldNumber; +const int BindRequest::kDeprecatedExportedServiceFieldNumber; +const int BindRequest::kExportedServiceFieldNumber; +const int BindRequest::kImportedServiceFieldNumber; +#endif // !_MSC_VER + +BindRequest::BindRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.connection.v1.BindRequest) +} + +void BindRequest::InitAsDefaultInstance() { +} + +BindRequest::BindRequest(const BindRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.connection.v1.BindRequest) +} + +void BindRequest::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +BindRequest::~BindRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.connection.v1.BindRequest) + SharedDtor(); +} + +void BindRequest::SharedDtor() { + if (this != default_instance_) { + } +} + +void BindRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* BindRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return BindRequest_descriptor_; +} + +const BindRequest& BindRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_connection_5fservice_2eproto(); + return *default_instance_; +} + +BindRequest* BindRequest::default_instance_ = NULL; + +BindRequest* BindRequest::New() const { + return new BindRequest; +} + +void BindRequest::Clear() { + deprecated_imported_service_hash_.Clear(); + deprecated_exported_service_.Clear(); + exported_service_.Clear(); + imported_service_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool BindRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.connection.v1.BindRequest) + 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 deprecated_imported_service_hash = 1 [packed = true, deprecated = true]; + case 1: { + if (tag == 10) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, this->mutable_deprecated_imported_service_hash()))); + } else if (tag == 13) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + 1, 10, input, this->mutable_deprecated_imported_service_hash()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_deprecated_exported_service; + break; + } + + // repeated .bgs.protocol.connection.v1.BoundService deprecated_exported_service = 2 [deprecated = true]; + case 2: { + if (tag == 18) { + parse_deprecated_exported_service: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_deprecated_exported_service())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_deprecated_exported_service; + if (input->ExpectTag(26)) goto parse_exported_service; + break; + } + + // repeated .bgs.protocol.connection.v1.BoundService exported_service = 3; + case 3: { + if (tag == 26) { + parse_exported_service: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_exported_service())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_exported_service; + if (input->ExpectTag(34)) goto parse_imported_service; + break; + } + + // repeated .bgs.protocol.connection.v1.BoundService imported_service = 4; + case 4: { + if (tag == 34) { + parse_imported_service: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_imported_service())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_imported_service; + 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:bgs.protocol.connection.v1.BindRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.connection.v1.BindRequest) + return false; +#undef DO_ +} + +void BindRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.connection.v1.BindRequest) + // repeated fixed32 deprecated_imported_service_hash = 1 [packed = true, deprecated = true]; + if (this->deprecated_imported_service_hash_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(1, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_deprecated_imported_service_hash_cached_byte_size_); + } + for (int i = 0; i < this->deprecated_imported_service_hash_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32NoTag( + this->deprecated_imported_service_hash(i), output); + } + + // repeated .bgs.protocol.connection.v1.BoundService deprecated_exported_service = 2 [deprecated = true]; + for (int i = 0; i < this->deprecated_exported_service_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->deprecated_exported_service(i), output); + } + + // repeated .bgs.protocol.connection.v1.BoundService exported_service = 3; + for (int i = 0; i < this->exported_service_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->exported_service(i), output); + } + + // repeated .bgs.protocol.connection.v1.BoundService imported_service = 4; + for (int i = 0; i < this->imported_service_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->imported_service(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.connection.v1.BindRequest) +} + +::google::protobuf::uint8* BindRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.connection.v1.BindRequest) + // repeated fixed32 deprecated_imported_service_hash = 1 [packed = true, deprecated = true]; + if (this->deprecated_imported_service_hash_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 1, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _deprecated_imported_service_hash_cached_byte_size_, target); + } + for (int i = 0; i < this->deprecated_imported_service_hash_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteFixed32NoTagToArray(this->deprecated_imported_service_hash(i), target); + } + + // repeated .bgs.protocol.connection.v1.BoundService deprecated_exported_service = 2 [deprecated = true]; + for (int i = 0; i < this->deprecated_exported_service_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->deprecated_exported_service(i), target); + } + + // repeated .bgs.protocol.connection.v1.BoundService exported_service = 3; + for (int i = 0; i < this->exported_service_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->exported_service(i), target); + } + + // repeated .bgs.protocol.connection.v1.BoundService imported_service = 4; + for (int i = 0; i < this->imported_service_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->imported_service(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.connection.v1.BindRequest) + return target; +} + +int BindRequest::ByteSize() const { + int total_size = 0; + + // repeated fixed32 deprecated_imported_service_hash = 1 [packed = true, deprecated = true]; + { + int data_size = 0; + data_size = 4 * this->deprecated_imported_service_hash_size(); + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _deprecated_imported_service_hash_cached_byte_size_ = data_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + // repeated .bgs.protocol.connection.v1.BoundService deprecated_exported_service = 2 [deprecated = true]; + total_size += 1 * this->deprecated_exported_service_size(); + for (int i = 0; i < this->deprecated_exported_service_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->deprecated_exported_service(i)); + } + + // repeated .bgs.protocol.connection.v1.BoundService exported_service = 3; + total_size += 1 * this->exported_service_size(); + for (int i = 0; i < this->exported_service_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->exported_service(i)); + } + + // repeated .bgs.protocol.connection.v1.BoundService imported_service = 4; + total_size += 1 * this->imported_service_size(); + for (int i = 0; i < this->imported_service_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->imported_service(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 BindRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const BindRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void BindRequest::MergeFrom(const BindRequest& from) { + GOOGLE_CHECK_NE(&from, this); + deprecated_imported_service_hash_.MergeFrom(from.deprecated_imported_service_hash_); + deprecated_exported_service_.MergeFrom(from.deprecated_exported_service_); + exported_service_.MergeFrom(from.exported_service_); + imported_service_.MergeFrom(from.imported_service_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void BindRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void BindRequest::CopyFrom(const BindRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BindRequest::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->deprecated_exported_service())) return false; + if (!::google::protobuf::internal::AllAreInitialized(this->exported_service())) return false; + if (!::google::protobuf::internal::AllAreInitialized(this->imported_service())) return false; + return true; +} + +void BindRequest::Swap(BindRequest* other) { + if (other != this) { + deprecated_imported_service_hash_.Swap(&other->deprecated_imported_service_hash_); + deprecated_exported_service_.Swap(&other->deprecated_exported_service_); + exported_service_.Swap(&other->exported_service_); + imported_service_.Swap(&other->imported_service_); + 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 BindRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = BindRequest_descriptor_; + metadata.reflection = BindRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int BindResponse::kImportedServiceIdFieldNumber; +#endif // !_MSC_VER + +BindResponse::BindResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.connection.v1.BindResponse) +} + +void BindResponse::InitAsDefaultInstance() { +} + +BindResponse::BindResponse(const BindResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.connection.v1.BindResponse) +} + +void BindResponse::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +BindResponse::~BindResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.connection.v1.BindResponse) + SharedDtor(); +} + +void BindResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void BindResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* BindResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return BindResponse_descriptor_; +} + +const BindResponse& BindResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_connection_5fservice_2eproto(); + return *default_instance_; +} + +BindResponse* BindResponse::default_instance_ = NULL; + +BindResponse* BindResponse::New() const { + return new BindResponse; +} + +void BindResponse::Clear() { + imported_service_id_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool BindResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.connection.v1.BindResponse) + 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 uint32 imported_service_id = 1 [packed = true, deprecated = true]; + case 1: { + if (tag == 10) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_imported_service_id()))); + } else if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 10, input, this->mutable_imported_service_id()))); + } 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:bgs.protocol.connection.v1.BindResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.connection.v1.BindResponse) + return false; +#undef DO_ +} + +void BindResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.connection.v1.BindResponse) + // repeated uint32 imported_service_id = 1 [packed = true, deprecated = true]; + if (this->imported_service_id_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(1, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_imported_service_id_cached_byte_size_); + } + for (int i = 0; i < this->imported_service_id_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag( + this->imported_service_id(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.connection.v1.BindResponse) +} + +::google::protobuf::uint8* BindResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.connection.v1.BindResponse) + // repeated uint32 imported_service_id = 1 [packed = true, deprecated = true]; + if (this->imported_service_id_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 1, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _imported_service_id_cached_byte_size_, target); + } + for (int i = 0; i < this->imported_service_id_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32NoTagToArray(this->imported_service_id(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.connection.v1.BindResponse) + return target; +} + +int BindResponse::ByteSize() const { + int total_size = 0; + + // repeated uint32 imported_service_id = 1 [packed = true, deprecated = true]; + { + int data_size = 0; + for (int i = 0; i < this->imported_service_id_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->imported_service_id(i)); + } + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _imported_service_id_cached_byte_size_ = data_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_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 BindResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const BindResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void BindResponse::MergeFrom(const BindResponse& from) { + GOOGLE_CHECK_NE(&from, this); + imported_service_id_.MergeFrom(from.imported_service_id_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void BindResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void BindResponse::CopyFrom(const BindResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BindResponse::IsInitialized() const { + + return true; +} + +void BindResponse::Swap(BindResponse* other) { + if (other != this) { + imported_service_id_.Swap(&other->imported_service_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata BindResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = BindResponse_descriptor_; + metadata.reflection = BindResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int EchoRequest::kTimeFieldNumber; +const int EchoRequest::kNetworkOnlyFieldNumber; +const int EchoRequest::kPayloadFieldNumber; +#endif // !_MSC_VER + +EchoRequest::EchoRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.connection.v1.EchoRequest) +} + +void EchoRequest::InitAsDefaultInstance() { +} + +EchoRequest::EchoRequest(const EchoRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.connection.v1.EchoRequest) +} + +void EchoRequest::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + time_ = GOOGLE_ULONGLONG(0); + network_only_ = false; + payload_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +EchoRequest::~EchoRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.connection.v1.EchoRequest) + SharedDtor(); +} + +void EchoRequest::SharedDtor() { + if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete payload_; + } + if (this != default_instance_) { + } +} + +void EchoRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* EchoRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return EchoRequest_descriptor_; +} + +const EchoRequest& EchoRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_connection_5fservice_2eproto(); + return *default_instance_; +} + +EchoRequest* EchoRequest::default_instance_ = NULL; + +EchoRequest* EchoRequest::New() const { + return new EchoRequest; +} + +void EchoRequest::Clear() { + if (_has_bits_[0 / 32] & 7) { + time_ = GOOGLE_ULONGLONG(0); + network_only_ = false; + if (has_payload()) { + if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + payload_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool EchoRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.connection.v1.EchoRequest) + 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 fixed64 time = 1; + case 1: { + if (tag == 9) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &time_))); + set_has_time(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_network_only; + break; + } + + // optional bool network_only = 2 [default = false]; + case 2: { + if (tag == 16) { + parse_network_only: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &network_only_))); + set_has_network_only(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_payload; + break; + } + + // optional bytes payload = 3; + case 3: { + if (tag == 26) { + parse_payload: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_payload())); + } 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:bgs.protocol.connection.v1.EchoRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.connection.v1.EchoRequest) + return false; +#undef DO_ +} + +void EchoRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.connection.v1.EchoRequest) + // optional fixed64 time = 1; + if (has_time()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->time(), output); + } + + // optional bool network_only = 2 [default = false]; + if (has_network_only()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->network_only(), output); + } + + // optional bytes payload = 3; + if (has_payload()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 3, this->payload(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.connection.v1.EchoRequest) +} + +::google::protobuf::uint8* EchoRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.connection.v1.EchoRequest) + // optional fixed64 time = 1; + if (has_time()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->time(), target); + } + + // optional bool network_only = 2 [default = false]; + if (has_network_only()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->network_only(), target); + } + + // optional bytes payload = 3; + if (has_payload()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 3, this->payload(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.connection.v1.EchoRequest) + return target; +} + +int EchoRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional fixed64 time = 1; + if (has_time()) { + total_size += 1 + 8; + } + + // optional bool network_only = 2 [default = false]; + if (has_network_only()) { + total_size += 1 + 1; + } + + // optional bytes payload = 3; + if (has_payload()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->payload()); + } + + } + 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 EchoRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const EchoRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void EchoRequest::MergeFrom(const EchoRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_time()) { + set_time(from.time()); + } + if (from.has_network_only()) { + set_network_only(from.network_only()); + } + if (from.has_payload()) { + set_payload(from.payload()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void EchoRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void EchoRequest::CopyFrom(const EchoRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool EchoRequest::IsInitialized() const { + + return true; +} + +void EchoRequest::Swap(EchoRequest* other) { + if (other != this) { + std::swap(time_, other->time_); + std::swap(network_only_, other->network_only_); + std::swap(payload_, other->payload_); + 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 EchoRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = EchoRequest_descriptor_; + metadata.reflection = EchoRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int EchoResponse::kTimeFieldNumber; +const int EchoResponse::kPayloadFieldNumber; +#endif // !_MSC_VER + +EchoResponse::EchoResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.connection.v1.EchoResponse) +} + +void EchoResponse::InitAsDefaultInstance() { +} + +EchoResponse::EchoResponse(const EchoResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.connection.v1.EchoResponse) +} + +void EchoResponse::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + time_ = GOOGLE_ULONGLONG(0); + payload_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +EchoResponse::~EchoResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.connection.v1.EchoResponse) + SharedDtor(); +} + +void EchoResponse::SharedDtor() { + if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete payload_; + } + if (this != default_instance_) { + } +} + +void EchoResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* EchoResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return EchoResponse_descriptor_; +} + +const EchoResponse& EchoResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_connection_5fservice_2eproto(); + return *default_instance_; +} + +EchoResponse* EchoResponse::default_instance_ = NULL; + +EchoResponse* EchoResponse::New() const { + return new EchoResponse; +} + +void EchoResponse::Clear() { + if (_has_bits_[0 / 32] & 3) { + time_ = GOOGLE_ULONGLONG(0); + if (has_payload()) { + if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + payload_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool EchoResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.connection.v1.EchoResponse) + 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 fixed64 time = 1; + case 1: { + if (tag == 9) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &time_))); + set_has_time(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_payload; + break; + } + + // optional bytes payload = 2; + case 2: { + if (tag == 18) { + parse_payload: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_payload())); + } 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:bgs.protocol.connection.v1.EchoResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.connection.v1.EchoResponse) + return false; +#undef DO_ +} + +void EchoResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.connection.v1.EchoResponse) + // optional fixed64 time = 1; + if (has_time()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->time(), output); + } + + // optional bytes payload = 2; + if (has_payload()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 2, this->payload(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.connection.v1.EchoResponse) +} + +::google::protobuf::uint8* EchoResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.connection.v1.EchoResponse) + // optional fixed64 time = 1; + if (has_time()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->time(), target); + } + + // optional bytes payload = 2; + if (has_payload()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 2, this->payload(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.connection.v1.EchoResponse) + return target; +} + +int EchoResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional fixed64 time = 1; + if (has_time()) { + total_size += 1 + 8; + } + + // optional bytes payload = 2; + if (has_payload()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->payload()); + } + + } + 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 EchoResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const EchoResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void EchoResponse::MergeFrom(const EchoResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_time()) { + set_time(from.time()); + } + if (from.has_payload()) { + set_payload(from.payload()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void EchoResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void EchoResponse::CopyFrom(const EchoResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool EchoResponse::IsInitialized() const { + + return true; +} + +void EchoResponse::Swap(EchoResponse* other) { + if (other != this) { + std::swap(time_, other->time_); + std::swap(payload_, other->payload_); + 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 EchoResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = EchoResponse_descriptor_; + metadata.reflection = EchoResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int DisconnectRequest::kErrorCodeFieldNumber; +#endif // !_MSC_VER + +DisconnectRequest::DisconnectRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.connection.v1.DisconnectRequest) +} + +void DisconnectRequest::InitAsDefaultInstance() { +} + +DisconnectRequest::DisconnectRequest(const DisconnectRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.connection.v1.DisconnectRequest) +} + +void DisconnectRequest::SharedCtor() { + _cached_size_ = 0; + error_code_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +DisconnectRequest::~DisconnectRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.connection.v1.DisconnectRequest) + SharedDtor(); +} + +void DisconnectRequest::SharedDtor() { + if (this != default_instance_) { + } +} + +void DisconnectRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* DisconnectRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return DisconnectRequest_descriptor_; +} + +const DisconnectRequest& DisconnectRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_connection_5fservice_2eproto(); + return *default_instance_; +} + +DisconnectRequest* DisconnectRequest::default_instance_ = NULL; + +DisconnectRequest* DisconnectRequest::New() const { + return new DisconnectRequest; +} + +void DisconnectRequest::Clear() { + error_code_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool DisconnectRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.connection.v1.DisconnectRequest) + 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)) { + // required uint32 error_code = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &error_code_))); + set_has_error_code(); + } 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:bgs.protocol.connection.v1.DisconnectRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.connection.v1.DisconnectRequest) + return false; +#undef DO_ +} + +void DisconnectRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.connection.v1.DisconnectRequest) + // required uint32 error_code = 1; + if (has_error_code()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->error_code(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.connection.v1.DisconnectRequest) +} + +::google::protobuf::uint8* DisconnectRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.connection.v1.DisconnectRequest) + // required uint32 error_code = 1; + if (has_error_code()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->error_code(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.connection.v1.DisconnectRequest) + return target; +} + +int DisconnectRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required uint32 error_code = 1; + if (has_error_code()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->error_code()); + } + + } + 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 DisconnectRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const DisconnectRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void DisconnectRequest::MergeFrom(const DisconnectRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_error_code()) { + set_error_code(from.error_code()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void DisconnectRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DisconnectRequest::CopyFrom(const DisconnectRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DisconnectRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void DisconnectRequest::Swap(DisconnectRequest* other) { + if (other != this) { + std::swap(error_code_, other->error_code_); + 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 DisconnectRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = DisconnectRequest_descriptor_; + metadata.reflection = DisconnectRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int DisconnectNotification::kErrorCodeFieldNumber; +const int DisconnectNotification::kReasonFieldNumber; +#endif // !_MSC_VER + +DisconnectNotification::DisconnectNotification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.connection.v1.DisconnectNotification) +} + +void DisconnectNotification::InitAsDefaultInstance() { +} + +DisconnectNotification::DisconnectNotification(const DisconnectNotification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.connection.v1.DisconnectNotification) +} + +void DisconnectNotification::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + error_code_ = 0u; + reason_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +DisconnectNotification::~DisconnectNotification() { + // @@protoc_insertion_point(destructor:bgs.protocol.connection.v1.DisconnectNotification) + SharedDtor(); +} + +void DisconnectNotification::SharedDtor() { + if (reason_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete reason_; + } + if (this != default_instance_) { + } +} + +void DisconnectNotification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* DisconnectNotification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return DisconnectNotification_descriptor_; +} + +const DisconnectNotification& DisconnectNotification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_connection_5fservice_2eproto(); + return *default_instance_; +} + +DisconnectNotification* DisconnectNotification::default_instance_ = NULL; + +DisconnectNotification* DisconnectNotification::New() const { + return new DisconnectNotification; +} + +void DisconnectNotification::Clear() { + if (_has_bits_[0 / 32] & 3) { + error_code_ = 0u; + if (has_reason()) { + if (reason_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + reason_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool DisconnectNotification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.connection.v1.DisconnectNotification) + 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)) { + // required uint32 error_code = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &error_code_))); + set_has_error_code(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_reason; + break; + } + + // optional string reason = 2; + case 2: { + if (tag == 18) { + parse_reason: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_reason())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->reason().data(), this->reason().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "reason"); + } 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:bgs.protocol.connection.v1.DisconnectNotification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.connection.v1.DisconnectNotification) + return false; +#undef DO_ +} + +void DisconnectNotification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.connection.v1.DisconnectNotification) + // required uint32 error_code = 1; + if (has_error_code()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->error_code(), output); + } + + // optional string reason = 2; + if (has_reason()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->reason().data(), this->reason().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "reason"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->reason(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.connection.v1.DisconnectNotification) +} + +::google::protobuf::uint8* DisconnectNotification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.connection.v1.DisconnectNotification) + // required uint32 error_code = 1; + if (has_error_code()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->error_code(), target); + } + + // optional string reason = 2; + if (has_reason()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->reason().data(), this->reason().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "reason"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->reason(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.connection.v1.DisconnectNotification) + return target; +} + +int DisconnectNotification::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required uint32 error_code = 1; + if (has_error_code()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->error_code()); + } + + // optional string reason = 2; + if (has_reason()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->reason()); + } + + } + 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 DisconnectNotification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const DisconnectNotification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void DisconnectNotification::MergeFrom(const DisconnectNotification& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_error_code()) { + set_error_code(from.error_code()); + } + if (from.has_reason()) { + set_reason(from.reason()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void DisconnectNotification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DisconnectNotification::CopyFrom(const DisconnectNotification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DisconnectNotification::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void DisconnectNotification::Swap(DisconnectNotification* other) { + if (other != this) { + std::swap(error_code_, other->error_code_); + std::swap(reason_, other->reason_); + 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 DisconnectNotification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = DisconnectNotification_descriptor_; + metadata.reflection = DisconnectNotification_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +#endif // !_MSC_VER + +EncryptRequest::EncryptRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.connection.v1.EncryptRequest) +} + +void EncryptRequest::InitAsDefaultInstance() { +} + +EncryptRequest::EncryptRequest(const EncryptRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.connection.v1.EncryptRequest) +} + +void EncryptRequest::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +EncryptRequest::~EncryptRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.connection.v1.EncryptRequest) + SharedDtor(); +} + +void EncryptRequest::SharedDtor() { + if (this != default_instance_) { + } +} + +void EncryptRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* EncryptRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return EncryptRequest_descriptor_; +} + +const EncryptRequest& EncryptRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_connection_5fservice_2eproto(); + return *default_instance_; +} + +EncryptRequest* EncryptRequest::default_instance_ = NULL; + +EncryptRequest* EncryptRequest::New() const { + return new EncryptRequest; +} + +void EncryptRequest::Clear() { + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool EncryptRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.connection.v1.EncryptRequest) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + 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())); + } +success: + // @@protoc_insertion_point(parse_success:bgs.protocol.connection.v1.EncryptRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.connection.v1.EncryptRequest) + return false; +#undef DO_ +} + +void EncryptRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.connection.v1.EncryptRequest) + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.connection.v1.EncryptRequest) +} + +::google::protobuf::uint8* EncryptRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.connection.v1.EncryptRequest) + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.connection.v1.EncryptRequest) + return target; +} + +int EncryptRequest::ByteSize() const { + int total_size = 0; + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void EncryptRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const EncryptRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void EncryptRequest::MergeFrom(const EncryptRequest& from) { + GOOGLE_CHECK_NE(&from, this); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void EncryptRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void EncryptRequest::CopyFrom(const EncryptRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool EncryptRequest::IsInitialized() const { + + return true; +} + +void EncryptRequest::Swap(EncryptRequest* other) { + if (other != this) { + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata EncryptRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = EncryptRequest_descriptor_; + metadata.reflection = EncryptRequest_reflection_; + return metadata; +} + + +// =================================================================== + +google::protobuf::ServiceDescriptor const* ConnectionService::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ConnectionService_descriptor_; +} + +void ConnectionService::Connect(::bgs::protocol::connection::v1::ConnectRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ConnectionService.Connect(bgs.protocol.connection.v1.ConnectRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 1, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::connection::v1::ConnectResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void ConnectionService::Bind(::bgs::protocol::connection::v1::BindRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ConnectionService.Bind(bgs.protocol.connection.v1.BindRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 2, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::connection::v1::BindResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void ConnectionService::Echo(::bgs::protocol::connection::v1::EchoRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ConnectionService.Echo(bgs.protocol.connection.v1.EchoRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 3, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::connection::v1::EchoResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void ConnectionService::ForceDisconnect(::bgs::protocol::connection::v1::DisconnectNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ConnectionService.ForceDisconnect(bgs.protocol.connection.v1.DisconnectNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 4, request); +} + +void ConnectionService::KeepAlive(::bgs::protocol::NoData const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ConnectionService.KeepAlive(bgs.protocol.NoData{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 5, request); +} + +void ConnectionService::Encrypt(::bgs::protocol::connection::v1::EncryptRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ConnectionService.Encrypt(bgs.protocol.connection.v1.EncryptRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 6, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void ConnectionService::RequestDisconnect(::bgs::protocol::connection::v1::DisconnectRequest const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ConnectionService.RequestDisconnect(bgs.protocol.connection.v1.DisconnectRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 7, request); +} + +void ConnectionService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) { + switch(methodId) { + case 1: { + ::bgs::protocol::connection::v1::ConnectRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ConnectionService.Connect server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::connection::v1::ConnectResponse response; + uint32 status = HandleConnect(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ConnectionService.Connect(bgs.protocol.connection.v1.ConnectRequest{ %s }) returned bgs.protocol.connection.v1.ConnectResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 1, token, &response); + else + SendResponse(service_hash_, 1, token, status); + break; + } + case 2: { + ::bgs::protocol::connection::v1::BindRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ConnectionService.Bind server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::connection::v1::BindResponse response; + uint32 status = HandleBind(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ConnectionService.Bind(bgs.protocol.connection.v1.BindRequest{ %s }) returned bgs.protocol.connection.v1.BindResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 2, token, &response); + else + SendResponse(service_hash_, 2, token, status); + break; + } + case 3: { + ::bgs::protocol::connection::v1::EchoRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ConnectionService.Echo server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::connection::v1::EchoResponse response; + uint32 status = HandleEcho(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ConnectionService.Echo(bgs.protocol.connection.v1.EchoRequest{ %s }) returned bgs.protocol.connection.v1.EchoResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 3, token, &response); + else + SendResponse(service_hash_, 3, token, status); + break; + } + case 4: { + ::bgs::protocol::connection::v1::DisconnectNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ConnectionService.ForceDisconnect server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleForceDisconnect(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ConnectionService.ForceDisconnect(bgs.protocol.connection.v1.DisconnectNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 4, token, status); + break; + } + case 5: { + ::bgs::protocol::NoData request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ConnectionService.KeepAlive server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 5, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleKeepAlive(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ConnectionService.KeepAlive(bgs.protocol.NoData{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 5, token, status); + break; + } + case 6: { + ::bgs::protocol::connection::v1::EncryptRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ConnectionService.Encrypt server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 6, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleEncrypt(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ConnectionService.Encrypt(bgs.protocol.connection.v1.EncryptRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 6, token, &response); + else + SendResponse(service_hash_, 6, token, status); + break; + } + case 7: { + ::bgs::protocol::connection::v1::DisconnectRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ConnectionService.RequestDisconnect server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 7, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleRequestDisconnect(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ConnectionService.RequestDisconnect(bgs.protocol.connection.v1.DisconnectRequest{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 7, token, status); + break; + } + default: + TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId); + SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD); + break; + } +} + +uint32 ConnectionService::HandleConnect(::bgs::protocol::connection::v1::ConnectRequest const* request, ::bgs::protocol::connection::v1::ConnectResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ConnectionService.Connect({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ConnectionService::HandleBind(::bgs::protocol::connection::v1::BindRequest const* request, ::bgs::protocol::connection::v1::BindResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ConnectionService.Bind({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ConnectionService::HandleEcho(::bgs::protocol::connection::v1::EchoRequest const* request, ::bgs::protocol::connection::v1::EchoResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ConnectionService.Echo({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ConnectionService::HandleForceDisconnect(::bgs::protocol::connection::v1::DisconnectNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ConnectionService.ForceDisconnect({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ConnectionService::HandleKeepAlive(::bgs::protocol::NoData const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ConnectionService.KeepAlive({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ConnectionService::HandleEncrypt(::bgs::protocol::connection::v1::EncryptRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ConnectionService.Encrypt({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 ConnectionService::HandleRequestDisconnect(::bgs::protocol::connection::v1::DisconnectRequest const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ConnectionService.RequestDisconnect({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace connection +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/connection_service.pb.h b/src/server/proto/Client/connection_service.pb.h new file mode 100644 index 00000000000..0629391f5cf --- /dev/null +++ b/src/server/proto/Client/connection_service.pb.h @@ -0,0 +1,2202 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: connection_service.proto + +#ifndef PROTOBUF_connection_5fservice_2eproto__INCLUDED +#define PROTOBUF_connection_5fservice_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include "content_handle_types.pb.h" +#include "rpc_types.pb.h" +#include "ServiceBase.h" +#include "MessageBuffer.h" +#include +#include +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { +namespace connection { +namespace v1 { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_connection_5fservice_2eproto(); +void protobuf_AssignDesc_connection_5fservice_2eproto(); +void protobuf_ShutdownFile_connection_5fservice_2eproto(); + +class ConnectRequest; +class ConnectionMeteringContentHandles; +class ConnectResponse; +class BoundService; +class BindRequest; +class BindResponse; +class EchoRequest; +class EchoResponse; +class DisconnectRequest; +class DisconnectNotification; +class EncryptRequest; + +// =================================================================== + +class TC_SHARED_API ConnectRequest : public ::google::protobuf::Message { + public: + ConnectRequest(); + virtual ~ConnectRequest(); + + ConnectRequest(const ConnectRequest& from); + + inline ConnectRequest& operator=(const ConnectRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ConnectRequest& default_instance(); + + void Swap(ConnectRequest* other); + + // implements Message ---------------------------------------------- + + ConnectRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ConnectRequest& from); + void MergeFrom(const ConnectRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.ProcessId client_id = 1; + inline bool has_client_id() const; + inline void clear_client_id(); + static const int kClientIdFieldNumber = 1; + inline const ::bgs::protocol::ProcessId& client_id() const; + inline ::bgs::protocol::ProcessId* mutable_client_id(); + inline ::bgs::protocol::ProcessId* release_client_id(); + inline void set_allocated_client_id(::bgs::protocol::ProcessId* client_id); + + // optional .bgs.protocol.connection.v1.BindRequest bind_request = 2; + inline bool has_bind_request() const; + inline void clear_bind_request(); + static const int kBindRequestFieldNumber = 2; + inline const ::bgs::protocol::connection::v1::BindRequest& bind_request() const; + inline ::bgs::protocol::connection::v1::BindRequest* mutable_bind_request(); + inline ::bgs::protocol::connection::v1::BindRequest* release_bind_request(); + inline void set_allocated_bind_request(::bgs::protocol::connection::v1::BindRequest* bind_request); + + // optional bool use_bindless_rpc = 3 [default = true]; + inline bool has_use_bindless_rpc() const; + inline void clear_use_bindless_rpc(); + static const int kUseBindlessRpcFieldNumber = 3; + inline bool use_bindless_rpc() const; + inline void set_use_bindless_rpc(bool value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.connection.v1.ConnectRequest) + private: + inline void set_has_client_id(); + inline void clear_has_client_id(); + inline void set_has_bind_request(); + inline void clear_has_bind_request(); + inline void set_has_use_bindless_rpc(); + inline void clear_has_use_bindless_rpc(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::ProcessId* client_id_; + ::bgs::protocol::connection::v1::BindRequest* bind_request_; + bool use_bindless_rpc_; + friend void TC_SHARED_API protobuf_AddDesc_connection_5fservice_2eproto(); + friend void protobuf_AssignDesc_connection_5fservice_2eproto(); + friend void protobuf_ShutdownFile_connection_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ConnectRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ConnectionMeteringContentHandles : public ::google::protobuf::Message { + public: + ConnectionMeteringContentHandles(); + virtual ~ConnectionMeteringContentHandles(); + + ConnectionMeteringContentHandles(const ConnectionMeteringContentHandles& from); + + inline ConnectionMeteringContentHandles& operator=(const ConnectionMeteringContentHandles& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ConnectionMeteringContentHandles& default_instance(); + + void Swap(ConnectionMeteringContentHandles* other); + + // implements Message ---------------------------------------------- + + ConnectionMeteringContentHandles* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ConnectionMeteringContentHandles& from); + void MergeFrom(const ConnectionMeteringContentHandles& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.ContentHandle content_handle = 1; + inline int content_handle_size() const; + inline void clear_content_handle(); + static const int kContentHandleFieldNumber = 1; + inline const ::bgs::protocol::ContentHandle& content_handle(int index) const; + inline ::bgs::protocol::ContentHandle* mutable_content_handle(int index); + inline ::bgs::protocol::ContentHandle* add_content_handle(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ContentHandle >& + content_handle() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ContentHandle >* + mutable_content_handle(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.connection.v1.ConnectionMeteringContentHandles) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ContentHandle > content_handle_; + friend void TC_SHARED_API protobuf_AddDesc_connection_5fservice_2eproto(); + friend void protobuf_AssignDesc_connection_5fservice_2eproto(); + friend void protobuf_ShutdownFile_connection_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ConnectionMeteringContentHandles* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ConnectResponse : public ::google::protobuf::Message { + public: + ConnectResponse(); + virtual ~ConnectResponse(); + + ConnectResponse(const ConnectResponse& from); + + inline ConnectResponse& operator=(const ConnectResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ConnectResponse& default_instance(); + + void Swap(ConnectResponse* other); + + // implements Message ---------------------------------------------- + + ConnectResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ConnectResponse& from); + void MergeFrom(const ConnectResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.ProcessId server_id = 1; + inline bool has_server_id() const; + inline void clear_server_id(); + static const int kServerIdFieldNumber = 1; + inline const ::bgs::protocol::ProcessId& server_id() const; + inline ::bgs::protocol::ProcessId* mutable_server_id(); + inline ::bgs::protocol::ProcessId* release_server_id(); + inline void set_allocated_server_id(::bgs::protocol::ProcessId* server_id); + + // optional .bgs.protocol.ProcessId client_id = 2; + inline bool has_client_id() const; + inline void clear_client_id(); + static const int kClientIdFieldNumber = 2; + inline const ::bgs::protocol::ProcessId& client_id() const; + inline ::bgs::protocol::ProcessId* mutable_client_id(); + inline ::bgs::protocol::ProcessId* release_client_id(); + inline void set_allocated_client_id(::bgs::protocol::ProcessId* client_id); + + // optional uint32 bind_result = 3; + inline bool has_bind_result() const; + inline void clear_bind_result(); + static const int kBindResultFieldNumber = 3; + inline ::google::protobuf::uint32 bind_result() const; + inline void set_bind_result(::google::protobuf::uint32 value); + + // optional .bgs.protocol.connection.v1.BindResponse bind_response = 4; + inline bool has_bind_response() const; + inline void clear_bind_response(); + static const int kBindResponseFieldNumber = 4; + inline const ::bgs::protocol::connection::v1::BindResponse& bind_response() const; + inline ::bgs::protocol::connection::v1::BindResponse* mutable_bind_response(); + inline ::bgs::protocol::connection::v1::BindResponse* release_bind_response(); + inline void set_allocated_bind_response(::bgs::protocol::connection::v1::BindResponse* bind_response); + + // optional .bgs.protocol.connection.v1.ConnectionMeteringContentHandles content_handle_array = 5; + inline bool has_content_handle_array() const; + inline void clear_content_handle_array(); + static const int kContentHandleArrayFieldNumber = 5; + inline const ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles& content_handle_array() const; + inline ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* mutable_content_handle_array(); + inline ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* release_content_handle_array(); + inline void set_allocated_content_handle_array(::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* content_handle_array); + + // optional uint64 server_time = 6; + inline bool has_server_time() const; + inline void clear_server_time(); + static const int kServerTimeFieldNumber = 6; + inline ::google::protobuf::uint64 server_time() const; + inline void set_server_time(::google::protobuf::uint64 value); + + // optional bool use_bindless_rpc = 7 [default = false]; + inline bool has_use_bindless_rpc() const; + inline void clear_use_bindless_rpc(); + static const int kUseBindlessRpcFieldNumber = 7; + inline bool use_bindless_rpc() const; + inline void set_use_bindless_rpc(bool value); + + // optional .bgs.protocol.connection.v1.ConnectionMeteringContentHandles binary_content_handle_array = 8; + inline bool has_binary_content_handle_array() const; + inline void clear_binary_content_handle_array(); + static const int kBinaryContentHandleArrayFieldNumber = 8; + inline const ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles& binary_content_handle_array() const; + inline ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* mutable_binary_content_handle_array(); + inline ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* release_binary_content_handle_array(); + inline void set_allocated_binary_content_handle_array(::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* binary_content_handle_array); + + // @@protoc_insertion_point(class_scope:bgs.protocol.connection.v1.ConnectResponse) + private: + inline void set_has_server_id(); + inline void clear_has_server_id(); + inline void set_has_client_id(); + inline void clear_has_client_id(); + inline void set_has_bind_result(); + inline void clear_has_bind_result(); + inline void set_has_bind_response(); + inline void clear_has_bind_response(); + inline void set_has_content_handle_array(); + inline void clear_has_content_handle_array(); + inline void set_has_server_time(); + inline void clear_has_server_time(); + inline void set_has_use_bindless_rpc(); + inline void clear_has_use_bindless_rpc(); + inline void set_has_binary_content_handle_array(); + inline void clear_has_binary_content_handle_array(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::ProcessId* server_id_; + ::bgs::protocol::ProcessId* client_id_; + ::bgs::protocol::connection::v1::BindResponse* bind_response_; + ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* content_handle_array_; + ::google::protobuf::uint32 bind_result_; + bool use_bindless_rpc_; + ::google::protobuf::uint64 server_time_; + ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* binary_content_handle_array_; + friend void TC_SHARED_API protobuf_AddDesc_connection_5fservice_2eproto(); + friend void protobuf_AssignDesc_connection_5fservice_2eproto(); + friend void protobuf_ShutdownFile_connection_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ConnectResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API BoundService : public ::google::protobuf::Message { + public: + BoundService(); + virtual ~BoundService(); + + BoundService(const BoundService& from); + + inline BoundService& operator=(const BoundService& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const BoundService& default_instance(); + + void Swap(BoundService* other); + + // implements Message ---------------------------------------------- + + BoundService* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const BoundService& from); + void MergeFrom(const BoundService& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed32 hash = 1; + inline bool has_hash() const; + inline void clear_hash(); + static const int kHashFieldNumber = 1; + inline ::google::protobuf::uint32 hash() const; + inline void set_hash(::google::protobuf::uint32 value); + + // required uint32 id = 2; + inline bool has_id() const; + inline void clear_id(); + static const int kIdFieldNumber = 2; + inline ::google::protobuf::uint32 id() const; + inline void set_id(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.connection.v1.BoundService) + private: + inline void set_has_hash(); + inline void clear_has_hash(); + inline void set_has_id(); + inline void clear_has_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 hash_; + ::google::protobuf::uint32 id_; + friend void TC_SHARED_API protobuf_AddDesc_connection_5fservice_2eproto(); + friend void protobuf_AssignDesc_connection_5fservice_2eproto(); + friend void protobuf_ShutdownFile_connection_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static BoundService* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API BindRequest : public ::google::protobuf::Message { + public: + BindRequest(); + virtual ~BindRequest(); + + BindRequest(const BindRequest& from); + + inline BindRequest& operator=(const BindRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const BindRequest& default_instance(); + + void Swap(BindRequest* other); + + // implements Message ---------------------------------------------- + + BindRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const BindRequest& from); + void MergeFrom(const BindRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated fixed32 deprecated_imported_service_hash = 1 [packed = true, deprecated = true]; + inline int deprecated_imported_service_hash_size() const PROTOBUF_DEPRECATED; + inline void clear_deprecated_imported_service_hash() PROTOBUF_DEPRECATED; + static const int kDeprecatedImportedServiceHashFieldNumber = 1; + inline ::google::protobuf::uint32 deprecated_imported_service_hash(int index) const PROTOBUF_DEPRECATED; + inline void set_deprecated_imported_service_hash(int index, ::google::protobuf::uint32 value) PROTOBUF_DEPRECATED; + inline void add_deprecated_imported_service_hash(::google::protobuf::uint32 value) PROTOBUF_DEPRECATED; + inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + deprecated_imported_service_hash() const PROTOBUF_DEPRECATED; + inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_deprecated_imported_service_hash() PROTOBUF_DEPRECATED; + + // repeated .bgs.protocol.connection.v1.BoundService deprecated_exported_service = 2 [deprecated = true]; + inline int deprecated_exported_service_size() const PROTOBUF_DEPRECATED; + inline void clear_deprecated_exported_service() PROTOBUF_DEPRECATED; + static const int kDeprecatedExportedServiceFieldNumber = 2; + inline const ::bgs::protocol::connection::v1::BoundService& deprecated_exported_service(int index) const PROTOBUF_DEPRECATED; + inline ::bgs::protocol::connection::v1::BoundService* mutable_deprecated_exported_service(int index) PROTOBUF_DEPRECATED; + inline ::bgs::protocol::connection::v1::BoundService* add_deprecated_exported_service() PROTOBUF_DEPRECATED; + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService >& + deprecated_exported_service() const PROTOBUF_DEPRECATED; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService >* + mutable_deprecated_exported_service() PROTOBUF_DEPRECATED; + + // repeated .bgs.protocol.connection.v1.BoundService exported_service = 3; + inline int exported_service_size() const; + inline void clear_exported_service(); + static const int kExportedServiceFieldNumber = 3; + inline const ::bgs::protocol::connection::v1::BoundService& exported_service(int index) const; + inline ::bgs::protocol::connection::v1::BoundService* mutable_exported_service(int index); + inline ::bgs::protocol::connection::v1::BoundService* add_exported_service(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService >& + exported_service() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService >* + mutable_exported_service(); + + // repeated .bgs.protocol.connection.v1.BoundService imported_service = 4; + inline int imported_service_size() const; + inline void clear_imported_service(); + static const int kImportedServiceFieldNumber = 4; + inline const ::bgs::protocol::connection::v1::BoundService& imported_service(int index) const; + inline ::bgs::protocol::connection::v1::BoundService* mutable_imported_service(int index); + inline ::bgs::protocol::connection::v1::BoundService* add_imported_service(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService >& + imported_service() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService >* + mutable_imported_service(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.connection.v1.BindRequest) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > deprecated_imported_service_hash_; + mutable int _deprecated_imported_service_hash_cached_byte_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService > deprecated_exported_service_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService > exported_service_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService > imported_service_; + friend void TC_SHARED_API protobuf_AddDesc_connection_5fservice_2eproto(); + friend void protobuf_AssignDesc_connection_5fservice_2eproto(); + friend void protobuf_ShutdownFile_connection_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static BindRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API BindResponse : public ::google::protobuf::Message { + public: + BindResponse(); + virtual ~BindResponse(); + + BindResponse(const BindResponse& from); + + inline BindResponse& operator=(const BindResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const BindResponse& default_instance(); + + void Swap(BindResponse* other); + + // implements Message ---------------------------------------------- + + BindResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const BindResponse& from); + void MergeFrom(const BindResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated uint32 imported_service_id = 1 [packed = true, deprecated = true]; + inline int imported_service_id_size() const PROTOBUF_DEPRECATED; + inline void clear_imported_service_id() PROTOBUF_DEPRECATED; + static const int kImportedServiceIdFieldNumber = 1; + inline ::google::protobuf::uint32 imported_service_id(int index) const PROTOBUF_DEPRECATED; + inline void set_imported_service_id(int index, ::google::protobuf::uint32 value) PROTOBUF_DEPRECATED; + inline void add_imported_service_id(::google::protobuf::uint32 value) PROTOBUF_DEPRECATED; + inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + imported_service_id() const PROTOBUF_DEPRECATED; + inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_imported_service_id() PROTOBUF_DEPRECATED; + + // @@protoc_insertion_point(class_scope:bgs.protocol.connection.v1.BindResponse) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > imported_service_id_; + mutable int _imported_service_id_cached_byte_size_; + friend void TC_SHARED_API protobuf_AddDesc_connection_5fservice_2eproto(); + friend void protobuf_AssignDesc_connection_5fservice_2eproto(); + friend void protobuf_ShutdownFile_connection_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static BindResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API EchoRequest : public ::google::protobuf::Message { + public: + EchoRequest(); + virtual ~EchoRequest(); + + EchoRequest(const EchoRequest& from); + + inline EchoRequest& operator=(const EchoRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const EchoRequest& default_instance(); + + void Swap(EchoRequest* other); + + // implements Message ---------------------------------------------- + + EchoRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const EchoRequest& from); + void MergeFrom(const EchoRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional fixed64 time = 1; + inline bool has_time() const; + inline void clear_time(); + static const int kTimeFieldNumber = 1; + inline ::google::protobuf::uint64 time() const; + inline void set_time(::google::protobuf::uint64 value); + + // optional bool network_only = 2 [default = false]; + inline bool has_network_only() const; + inline void clear_network_only(); + static const int kNetworkOnlyFieldNumber = 2; + inline bool network_only() const; + inline void set_network_only(bool value); + + // optional bytes payload = 3; + inline bool has_payload() const; + inline void clear_payload(); + static const int kPayloadFieldNumber = 3; + inline const ::std::string& payload() const; + inline void set_payload(const ::std::string& value); + inline void set_payload(const char* value); + inline void set_payload(const void* value, size_t size); + inline ::std::string* mutable_payload(); + inline ::std::string* release_payload(); + inline void set_allocated_payload(::std::string* payload); + + // @@protoc_insertion_point(class_scope:bgs.protocol.connection.v1.EchoRequest) + private: + inline void set_has_time(); + inline void clear_has_time(); + inline void set_has_network_only(); + inline void clear_has_network_only(); + inline void set_has_payload(); + inline void clear_has_payload(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint64 time_; + ::std::string* payload_; + bool network_only_; + friend void TC_SHARED_API protobuf_AddDesc_connection_5fservice_2eproto(); + friend void protobuf_AssignDesc_connection_5fservice_2eproto(); + friend void protobuf_ShutdownFile_connection_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static EchoRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API EchoResponse : public ::google::protobuf::Message { + public: + EchoResponse(); + virtual ~EchoResponse(); + + EchoResponse(const EchoResponse& from); + + inline EchoResponse& operator=(const EchoResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const EchoResponse& default_instance(); + + void Swap(EchoResponse* other); + + // implements Message ---------------------------------------------- + + EchoResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const EchoResponse& from); + void MergeFrom(const EchoResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional fixed64 time = 1; + inline bool has_time() const; + inline void clear_time(); + static const int kTimeFieldNumber = 1; + inline ::google::protobuf::uint64 time() const; + inline void set_time(::google::protobuf::uint64 value); + + // optional bytes payload = 2; + inline bool has_payload() const; + inline void clear_payload(); + static const int kPayloadFieldNumber = 2; + inline const ::std::string& payload() const; + inline void set_payload(const ::std::string& value); + inline void set_payload(const char* value); + inline void set_payload(const void* value, size_t size); + inline ::std::string* mutable_payload(); + inline ::std::string* release_payload(); + inline void set_allocated_payload(::std::string* payload); + + // @@protoc_insertion_point(class_scope:bgs.protocol.connection.v1.EchoResponse) + private: + inline void set_has_time(); + inline void clear_has_time(); + inline void set_has_payload(); + inline void clear_has_payload(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint64 time_; + ::std::string* payload_; + friend void TC_SHARED_API protobuf_AddDesc_connection_5fservice_2eproto(); + friend void protobuf_AssignDesc_connection_5fservice_2eproto(); + friend void protobuf_ShutdownFile_connection_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static EchoResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API DisconnectRequest : public ::google::protobuf::Message { + public: + DisconnectRequest(); + virtual ~DisconnectRequest(); + + DisconnectRequest(const DisconnectRequest& from); + + inline DisconnectRequest& operator=(const DisconnectRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const DisconnectRequest& default_instance(); + + void Swap(DisconnectRequest* other); + + // implements Message ---------------------------------------------- + + DisconnectRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const DisconnectRequest& from); + void MergeFrom(const DisconnectRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required uint32 error_code = 1; + inline bool has_error_code() const; + inline void clear_error_code(); + static const int kErrorCodeFieldNumber = 1; + inline ::google::protobuf::uint32 error_code() const; + inline void set_error_code(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.connection.v1.DisconnectRequest) + private: + inline void set_has_error_code(); + inline void clear_has_error_code(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 error_code_; + friend void TC_SHARED_API protobuf_AddDesc_connection_5fservice_2eproto(); + friend void protobuf_AssignDesc_connection_5fservice_2eproto(); + friend void protobuf_ShutdownFile_connection_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static DisconnectRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API DisconnectNotification : public ::google::protobuf::Message { + public: + DisconnectNotification(); + virtual ~DisconnectNotification(); + + DisconnectNotification(const DisconnectNotification& from); + + inline DisconnectNotification& operator=(const DisconnectNotification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const DisconnectNotification& default_instance(); + + void Swap(DisconnectNotification* other); + + // implements Message ---------------------------------------------- + + DisconnectNotification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const DisconnectNotification& from); + void MergeFrom(const DisconnectNotification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required uint32 error_code = 1; + inline bool has_error_code() const; + inline void clear_error_code(); + static const int kErrorCodeFieldNumber = 1; + inline ::google::protobuf::uint32 error_code() const; + inline void set_error_code(::google::protobuf::uint32 value); + + // optional string reason = 2; + inline bool has_reason() const; + inline void clear_reason(); + static const int kReasonFieldNumber = 2; + inline const ::std::string& reason() const; + inline void set_reason(const ::std::string& value); + inline void set_reason(const char* value); + inline void set_reason(const char* value, size_t size); + inline ::std::string* mutable_reason(); + inline ::std::string* release_reason(); + inline void set_allocated_reason(::std::string* reason); + + // @@protoc_insertion_point(class_scope:bgs.protocol.connection.v1.DisconnectNotification) + private: + inline void set_has_error_code(); + inline void clear_has_error_code(); + inline void set_has_reason(); + inline void clear_has_reason(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* reason_; + ::google::protobuf::uint32 error_code_; + friend void TC_SHARED_API protobuf_AddDesc_connection_5fservice_2eproto(); + friend void protobuf_AssignDesc_connection_5fservice_2eproto(); + friend void protobuf_ShutdownFile_connection_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static DisconnectNotification* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API EncryptRequest : public ::google::protobuf::Message { + public: + EncryptRequest(); + virtual ~EncryptRequest(); + + EncryptRequest(const EncryptRequest& from); + + inline EncryptRequest& operator=(const EncryptRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const EncryptRequest& default_instance(); + + void Swap(EncryptRequest* other); + + // implements Message ---------------------------------------------- + + EncryptRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const EncryptRequest& from); + void MergeFrom(const EncryptRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:bgs.protocol.connection.v1.EncryptRequest) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + friend void TC_SHARED_API protobuf_AddDesc_connection_5fservice_2eproto(); + friend void protobuf_AssignDesc_connection_5fservice_2eproto(); + friend void protobuf_ShutdownFile_connection_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static EncryptRequest* default_instance_; +}; +// =================================================================== + +class TC_SHARED_API ConnectionService : public ServiceBase +{ + public: + + template + explicit ConnectionService(HashSelector) : service_hash_(HashSelector::Result::value) { } + + typedef std::integral_constant OriginalHash; + typedef std::integral_constant NameHash; + + static google::protobuf::ServiceDescriptor const* descriptor(); + + // client methods -------------------------------------------------- + + void Connect(::bgs::protocol::connection::v1::ConnectRequest const* request, std::function responseCallback); + void Bind(::bgs::protocol::connection::v1::BindRequest const* request, std::function responseCallback); + void Echo(::bgs::protocol::connection::v1::EchoRequest const* request, std::function responseCallback); + void ForceDisconnect(::bgs::protocol::connection::v1::DisconnectNotification const* request); + void KeepAlive(::bgs::protocol::NoData const* request); + void Encrypt(::bgs::protocol::connection::v1::EncryptRequest const* request, std::function responseCallback); + void RequestDisconnect(::bgs::protocol::connection::v1::DisconnectRequest const* request); + // server methods -------------------------------------------------- + + void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final; + + protected: + virtual uint32 HandleConnect(::bgs::protocol::connection::v1::ConnectRequest const* request, ::bgs::protocol::connection::v1::ConnectResponse* response); + virtual uint32 HandleBind(::bgs::protocol::connection::v1::BindRequest const* request, ::bgs::protocol::connection::v1::BindResponse* response); + virtual uint32 HandleEcho(::bgs::protocol::connection::v1::EchoRequest const* request, ::bgs::protocol::connection::v1::EchoResponse* response); + virtual uint32 HandleForceDisconnect(::bgs::protocol::connection::v1::DisconnectNotification const* request); + virtual uint32 HandleKeepAlive(::bgs::protocol::NoData const* request); + virtual uint32 HandleEncrypt(::bgs::protocol::connection::v1::EncryptRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleRequestDisconnect(::bgs::protocol::connection::v1::DisconnectRequest const* request); + + private: + uint32 service_hash_; + + GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ConnectionService); +}; + +// =================================================================== + + +// =================================================================== + +// ConnectRequest + +// optional .bgs.protocol.ProcessId client_id = 1; +inline bool ConnectRequest::has_client_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ConnectRequest::set_has_client_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void ConnectRequest::clear_has_client_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ConnectRequest::clear_client_id() { + if (client_id_ != NULL) client_id_->::bgs::protocol::ProcessId::Clear(); + clear_has_client_id(); +} +inline const ::bgs::protocol::ProcessId& ConnectRequest::client_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.ConnectRequest.client_id) + return client_id_ != NULL ? *client_id_ : *default_instance_->client_id_; +} +inline ::bgs::protocol::ProcessId* ConnectRequest::mutable_client_id() { + set_has_client_id(); + if (client_id_ == NULL) client_id_ = new ::bgs::protocol::ProcessId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.ConnectRequest.client_id) + return client_id_; +} +inline ::bgs::protocol::ProcessId* ConnectRequest::release_client_id() { + clear_has_client_id(); + ::bgs::protocol::ProcessId* temp = client_id_; + client_id_ = NULL; + return temp; +} +inline void ConnectRequest::set_allocated_client_id(::bgs::protocol::ProcessId* client_id) { + delete client_id_; + client_id_ = client_id; + if (client_id) { + set_has_client_id(); + } else { + clear_has_client_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.connection.v1.ConnectRequest.client_id) +} + +// optional .bgs.protocol.connection.v1.BindRequest bind_request = 2; +inline bool ConnectRequest::has_bind_request() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ConnectRequest::set_has_bind_request() { + _has_bits_[0] |= 0x00000002u; +} +inline void ConnectRequest::clear_has_bind_request() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ConnectRequest::clear_bind_request() { + if (bind_request_ != NULL) bind_request_->::bgs::protocol::connection::v1::BindRequest::Clear(); + clear_has_bind_request(); +} +inline const ::bgs::protocol::connection::v1::BindRequest& ConnectRequest::bind_request() const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.ConnectRequest.bind_request) + return bind_request_ != NULL ? *bind_request_ : *default_instance_->bind_request_; +} +inline ::bgs::protocol::connection::v1::BindRequest* ConnectRequest::mutable_bind_request() { + set_has_bind_request(); + if (bind_request_ == NULL) bind_request_ = new ::bgs::protocol::connection::v1::BindRequest; + // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.ConnectRequest.bind_request) + return bind_request_; +} +inline ::bgs::protocol::connection::v1::BindRequest* ConnectRequest::release_bind_request() { + clear_has_bind_request(); + ::bgs::protocol::connection::v1::BindRequest* temp = bind_request_; + bind_request_ = NULL; + return temp; +} +inline void ConnectRequest::set_allocated_bind_request(::bgs::protocol::connection::v1::BindRequest* bind_request) { + delete bind_request_; + bind_request_ = bind_request; + if (bind_request) { + set_has_bind_request(); + } else { + clear_has_bind_request(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.connection.v1.ConnectRequest.bind_request) +} + +// optional bool use_bindless_rpc = 3 [default = true]; +inline bool ConnectRequest::has_use_bindless_rpc() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ConnectRequest::set_has_use_bindless_rpc() { + _has_bits_[0] |= 0x00000004u; +} +inline void ConnectRequest::clear_has_use_bindless_rpc() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ConnectRequest::clear_use_bindless_rpc() { + use_bindless_rpc_ = true; + clear_has_use_bindless_rpc(); +} +inline bool ConnectRequest::use_bindless_rpc() const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.ConnectRequest.use_bindless_rpc) + return use_bindless_rpc_; +} +inline void ConnectRequest::set_use_bindless_rpc(bool value) { + set_has_use_bindless_rpc(); + use_bindless_rpc_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.ConnectRequest.use_bindless_rpc) +} + +// ------------------------------------------------------------------- + +// ConnectionMeteringContentHandles + +// repeated .bgs.protocol.ContentHandle content_handle = 1; +inline int ConnectionMeteringContentHandles::content_handle_size() const { + return content_handle_.size(); +} +inline void ConnectionMeteringContentHandles::clear_content_handle() { + content_handle_.Clear(); +} +inline const ::bgs::protocol::ContentHandle& ConnectionMeteringContentHandles::content_handle(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.ConnectionMeteringContentHandles.content_handle) + return content_handle_.Get(index); +} +inline ::bgs::protocol::ContentHandle* ConnectionMeteringContentHandles::mutable_content_handle(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.ConnectionMeteringContentHandles.content_handle) + return content_handle_.Mutable(index); +} +inline ::bgs::protocol::ContentHandle* ConnectionMeteringContentHandles::add_content_handle() { + // @@protoc_insertion_point(field_add:bgs.protocol.connection.v1.ConnectionMeteringContentHandles.content_handle) + return content_handle_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ContentHandle >& +ConnectionMeteringContentHandles::content_handle() const { + // @@protoc_insertion_point(field_list:bgs.protocol.connection.v1.ConnectionMeteringContentHandles.content_handle) + return content_handle_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ContentHandle >* +ConnectionMeteringContentHandles::mutable_content_handle() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.connection.v1.ConnectionMeteringContentHandles.content_handle) + return &content_handle_; +} + +// ------------------------------------------------------------------- + +// ConnectResponse + +// required .bgs.protocol.ProcessId server_id = 1; +inline bool ConnectResponse::has_server_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ConnectResponse::set_has_server_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void ConnectResponse::clear_has_server_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ConnectResponse::clear_server_id() { + if (server_id_ != NULL) server_id_->::bgs::protocol::ProcessId::Clear(); + clear_has_server_id(); +} +inline const ::bgs::protocol::ProcessId& ConnectResponse::server_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.ConnectResponse.server_id) + return server_id_ != NULL ? *server_id_ : *default_instance_->server_id_; +} +inline ::bgs::protocol::ProcessId* ConnectResponse::mutable_server_id() { + set_has_server_id(); + if (server_id_ == NULL) server_id_ = new ::bgs::protocol::ProcessId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.ConnectResponse.server_id) + return server_id_; +} +inline ::bgs::protocol::ProcessId* ConnectResponse::release_server_id() { + clear_has_server_id(); + ::bgs::protocol::ProcessId* temp = server_id_; + server_id_ = NULL; + return temp; +} +inline void ConnectResponse::set_allocated_server_id(::bgs::protocol::ProcessId* server_id) { + delete server_id_; + server_id_ = server_id; + if (server_id) { + set_has_server_id(); + } else { + clear_has_server_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.connection.v1.ConnectResponse.server_id) +} + +// optional .bgs.protocol.ProcessId client_id = 2; +inline bool ConnectResponse::has_client_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ConnectResponse::set_has_client_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void ConnectResponse::clear_has_client_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ConnectResponse::clear_client_id() { + if (client_id_ != NULL) client_id_->::bgs::protocol::ProcessId::Clear(); + clear_has_client_id(); +} +inline const ::bgs::protocol::ProcessId& ConnectResponse::client_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.ConnectResponse.client_id) + return client_id_ != NULL ? *client_id_ : *default_instance_->client_id_; +} +inline ::bgs::protocol::ProcessId* ConnectResponse::mutable_client_id() { + set_has_client_id(); + if (client_id_ == NULL) client_id_ = new ::bgs::protocol::ProcessId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.ConnectResponse.client_id) + return client_id_; +} +inline ::bgs::protocol::ProcessId* ConnectResponse::release_client_id() { + clear_has_client_id(); + ::bgs::protocol::ProcessId* temp = client_id_; + client_id_ = NULL; + return temp; +} +inline void ConnectResponse::set_allocated_client_id(::bgs::protocol::ProcessId* client_id) { + delete client_id_; + client_id_ = client_id; + if (client_id) { + set_has_client_id(); + } else { + clear_has_client_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.connection.v1.ConnectResponse.client_id) +} + +// optional uint32 bind_result = 3; +inline bool ConnectResponse::has_bind_result() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ConnectResponse::set_has_bind_result() { + _has_bits_[0] |= 0x00000004u; +} +inline void ConnectResponse::clear_has_bind_result() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ConnectResponse::clear_bind_result() { + bind_result_ = 0u; + clear_has_bind_result(); +} +inline ::google::protobuf::uint32 ConnectResponse::bind_result() const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.ConnectResponse.bind_result) + return bind_result_; +} +inline void ConnectResponse::set_bind_result(::google::protobuf::uint32 value) { + set_has_bind_result(); + bind_result_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.ConnectResponse.bind_result) +} + +// optional .bgs.protocol.connection.v1.BindResponse bind_response = 4; +inline bool ConnectResponse::has_bind_response() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void ConnectResponse::set_has_bind_response() { + _has_bits_[0] |= 0x00000008u; +} +inline void ConnectResponse::clear_has_bind_response() { + _has_bits_[0] &= ~0x00000008u; +} +inline void ConnectResponse::clear_bind_response() { + if (bind_response_ != NULL) bind_response_->::bgs::protocol::connection::v1::BindResponse::Clear(); + clear_has_bind_response(); +} +inline const ::bgs::protocol::connection::v1::BindResponse& ConnectResponse::bind_response() const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.ConnectResponse.bind_response) + return bind_response_ != NULL ? *bind_response_ : *default_instance_->bind_response_; +} +inline ::bgs::protocol::connection::v1::BindResponse* ConnectResponse::mutable_bind_response() { + set_has_bind_response(); + if (bind_response_ == NULL) bind_response_ = new ::bgs::protocol::connection::v1::BindResponse; + // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.ConnectResponse.bind_response) + return bind_response_; +} +inline ::bgs::protocol::connection::v1::BindResponse* ConnectResponse::release_bind_response() { + clear_has_bind_response(); + ::bgs::protocol::connection::v1::BindResponse* temp = bind_response_; + bind_response_ = NULL; + return temp; +} +inline void ConnectResponse::set_allocated_bind_response(::bgs::protocol::connection::v1::BindResponse* bind_response) { + delete bind_response_; + bind_response_ = bind_response; + if (bind_response) { + set_has_bind_response(); + } else { + clear_has_bind_response(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.connection.v1.ConnectResponse.bind_response) +} + +// optional .bgs.protocol.connection.v1.ConnectionMeteringContentHandles content_handle_array = 5; +inline bool ConnectResponse::has_content_handle_array() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void ConnectResponse::set_has_content_handle_array() { + _has_bits_[0] |= 0x00000010u; +} +inline void ConnectResponse::clear_has_content_handle_array() { + _has_bits_[0] &= ~0x00000010u; +} +inline void ConnectResponse::clear_content_handle_array() { + if (content_handle_array_ != NULL) content_handle_array_->::bgs::protocol::connection::v1::ConnectionMeteringContentHandles::Clear(); + clear_has_content_handle_array(); +} +inline const ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles& ConnectResponse::content_handle_array() const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.ConnectResponse.content_handle_array) + return content_handle_array_ != NULL ? *content_handle_array_ : *default_instance_->content_handle_array_; +} +inline ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* ConnectResponse::mutable_content_handle_array() { + set_has_content_handle_array(); + if (content_handle_array_ == NULL) content_handle_array_ = new ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles; + // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.ConnectResponse.content_handle_array) + return content_handle_array_; +} +inline ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* ConnectResponse::release_content_handle_array() { + clear_has_content_handle_array(); + ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* temp = content_handle_array_; + content_handle_array_ = NULL; + return temp; +} +inline void ConnectResponse::set_allocated_content_handle_array(::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* content_handle_array) { + delete content_handle_array_; + content_handle_array_ = content_handle_array; + if (content_handle_array) { + set_has_content_handle_array(); + } else { + clear_has_content_handle_array(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.connection.v1.ConnectResponse.content_handle_array) +} + +// optional uint64 server_time = 6; +inline bool ConnectResponse::has_server_time() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void ConnectResponse::set_has_server_time() { + _has_bits_[0] |= 0x00000020u; +} +inline void ConnectResponse::clear_has_server_time() { + _has_bits_[0] &= ~0x00000020u; +} +inline void ConnectResponse::clear_server_time() { + server_time_ = GOOGLE_ULONGLONG(0); + clear_has_server_time(); +} +inline ::google::protobuf::uint64 ConnectResponse::server_time() const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.ConnectResponse.server_time) + return server_time_; +} +inline void ConnectResponse::set_server_time(::google::protobuf::uint64 value) { + set_has_server_time(); + server_time_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.ConnectResponse.server_time) +} + +// optional bool use_bindless_rpc = 7 [default = false]; +inline bool ConnectResponse::has_use_bindless_rpc() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void ConnectResponse::set_has_use_bindless_rpc() { + _has_bits_[0] |= 0x00000040u; +} +inline void ConnectResponse::clear_has_use_bindless_rpc() { + _has_bits_[0] &= ~0x00000040u; +} +inline void ConnectResponse::clear_use_bindless_rpc() { + use_bindless_rpc_ = false; + clear_has_use_bindless_rpc(); +} +inline bool ConnectResponse::use_bindless_rpc() const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.ConnectResponse.use_bindless_rpc) + return use_bindless_rpc_; +} +inline void ConnectResponse::set_use_bindless_rpc(bool value) { + set_has_use_bindless_rpc(); + use_bindless_rpc_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.ConnectResponse.use_bindless_rpc) +} + +// optional .bgs.protocol.connection.v1.ConnectionMeteringContentHandles binary_content_handle_array = 8; +inline bool ConnectResponse::has_binary_content_handle_array() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void ConnectResponse::set_has_binary_content_handle_array() { + _has_bits_[0] |= 0x00000080u; +} +inline void ConnectResponse::clear_has_binary_content_handle_array() { + _has_bits_[0] &= ~0x00000080u; +} +inline void ConnectResponse::clear_binary_content_handle_array() { + if (binary_content_handle_array_ != NULL) binary_content_handle_array_->::bgs::protocol::connection::v1::ConnectionMeteringContentHandles::Clear(); + clear_has_binary_content_handle_array(); +} +inline const ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles& ConnectResponse::binary_content_handle_array() const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.ConnectResponse.binary_content_handle_array) + return binary_content_handle_array_ != NULL ? *binary_content_handle_array_ : *default_instance_->binary_content_handle_array_; +} +inline ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* ConnectResponse::mutable_binary_content_handle_array() { + set_has_binary_content_handle_array(); + if (binary_content_handle_array_ == NULL) binary_content_handle_array_ = new ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles; + // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.ConnectResponse.binary_content_handle_array) + return binary_content_handle_array_; +} +inline ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* ConnectResponse::release_binary_content_handle_array() { + clear_has_binary_content_handle_array(); + ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* temp = binary_content_handle_array_; + binary_content_handle_array_ = NULL; + return temp; +} +inline void ConnectResponse::set_allocated_binary_content_handle_array(::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* binary_content_handle_array) { + delete binary_content_handle_array_; + binary_content_handle_array_ = binary_content_handle_array; + if (binary_content_handle_array) { + set_has_binary_content_handle_array(); + } else { + clear_has_binary_content_handle_array(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.connection.v1.ConnectResponse.binary_content_handle_array) +} + +// ------------------------------------------------------------------- + +// BoundService + +// required fixed32 hash = 1; +inline bool BoundService::has_hash() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void BoundService::set_has_hash() { + _has_bits_[0] |= 0x00000001u; +} +inline void BoundService::clear_has_hash() { + _has_bits_[0] &= ~0x00000001u; +} +inline void BoundService::clear_hash() { + hash_ = 0u; + clear_has_hash(); +} +inline ::google::protobuf::uint32 BoundService::hash() const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.BoundService.hash) + return hash_; +} +inline void BoundService::set_hash(::google::protobuf::uint32 value) { + set_has_hash(); + hash_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.BoundService.hash) +} + +// required uint32 id = 2; +inline bool BoundService::has_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void BoundService::set_has_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void BoundService::clear_has_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void BoundService::clear_id() { + id_ = 0u; + clear_has_id(); +} +inline ::google::protobuf::uint32 BoundService::id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.BoundService.id) + return id_; +} +inline void BoundService::set_id(::google::protobuf::uint32 value) { + set_has_id(); + id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.BoundService.id) +} + +// ------------------------------------------------------------------- + +// BindRequest + +// repeated fixed32 deprecated_imported_service_hash = 1 [packed = true, deprecated = true]; +inline int BindRequest::deprecated_imported_service_hash_size() const { + return deprecated_imported_service_hash_.size(); +} +inline void BindRequest::clear_deprecated_imported_service_hash() { + deprecated_imported_service_hash_.Clear(); +} +inline ::google::protobuf::uint32 BindRequest::deprecated_imported_service_hash(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.BindRequest.deprecated_imported_service_hash) + return deprecated_imported_service_hash_.Get(index); +} +inline void BindRequest::set_deprecated_imported_service_hash(int index, ::google::protobuf::uint32 value) { + deprecated_imported_service_hash_.Set(index, value); + // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.BindRequest.deprecated_imported_service_hash) +} +inline void BindRequest::add_deprecated_imported_service_hash(::google::protobuf::uint32 value) { + deprecated_imported_service_hash_.Add(value); + // @@protoc_insertion_point(field_add:bgs.protocol.connection.v1.BindRequest.deprecated_imported_service_hash) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +BindRequest::deprecated_imported_service_hash() const { + // @@protoc_insertion_point(field_list:bgs.protocol.connection.v1.BindRequest.deprecated_imported_service_hash) + return deprecated_imported_service_hash_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +BindRequest::mutable_deprecated_imported_service_hash() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.connection.v1.BindRequest.deprecated_imported_service_hash) + return &deprecated_imported_service_hash_; +} + +// repeated .bgs.protocol.connection.v1.BoundService deprecated_exported_service = 2 [deprecated = true]; +inline int BindRequest::deprecated_exported_service_size() const { + return deprecated_exported_service_.size(); +} +inline void BindRequest::clear_deprecated_exported_service() { + deprecated_exported_service_.Clear(); +} +inline const ::bgs::protocol::connection::v1::BoundService& BindRequest::deprecated_exported_service(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.BindRequest.deprecated_exported_service) + return deprecated_exported_service_.Get(index); +} +inline ::bgs::protocol::connection::v1::BoundService* BindRequest::mutable_deprecated_exported_service(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.BindRequest.deprecated_exported_service) + return deprecated_exported_service_.Mutable(index); +} +inline ::bgs::protocol::connection::v1::BoundService* BindRequest::add_deprecated_exported_service() { + // @@protoc_insertion_point(field_add:bgs.protocol.connection.v1.BindRequest.deprecated_exported_service) + return deprecated_exported_service_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService >& +BindRequest::deprecated_exported_service() const { + // @@protoc_insertion_point(field_list:bgs.protocol.connection.v1.BindRequest.deprecated_exported_service) + return deprecated_exported_service_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService >* +BindRequest::mutable_deprecated_exported_service() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.connection.v1.BindRequest.deprecated_exported_service) + return &deprecated_exported_service_; +} + +// repeated .bgs.protocol.connection.v1.BoundService exported_service = 3; +inline int BindRequest::exported_service_size() const { + return exported_service_.size(); +} +inline void BindRequest::clear_exported_service() { + exported_service_.Clear(); +} +inline const ::bgs::protocol::connection::v1::BoundService& BindRequest::exported_service(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.BindRequest.exported_service) + return exported_service_.Get(index); +} +inline ::bgs::protocol::connection::v1::BoundService* BindRequest::mutable_exported_service(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.BindRequest.exported_service) + return exported_service_.Mutable(index); +} +inline ::bgs::protocol::connection::v1::BoundService* BindRequest::add_exported_service() { + // @@protoc_insertion_point(field_add:bgs.protocol.connection.v1.BindRequest.exported_service) + return exported_service_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService >& +BindRequest::exported_service() const { + // @@protoc_insertion_point(field_list:bgs.protocol.connection.v1.BindRequest.exported_service) + return exported_service_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService >* +BindRequest::mutable_exported_service() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.connection.v1.BindRequest.exported_service) + return &exported_service_; +} + +// repeated .bgs.protocol.connection.v1.BoundService imported_service = 4; +inline int BindRequest::imported_service_size() const { + return imported_service_.size(); +} +inline void BindRequest::clear_imported_service() { + imported_service_.Clear(); +} +inline const ::bgs::protocol::connection::v1::BoundService& BindRequest::imported_service(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.BindRequest.imported_service) + return imported_service_.Get(index); +} +inline ::bgs::protocol::connection::v1::BoundService* BindRequest::mutable_imported_service(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.BindRequest.imported_service) + return imported_service_.Mutable(index); +} +inline ::bgs::protocol::connection::v1::BoundService* BindRequest::add_imported_service() { + // @@protoc_insertion_point(field_add:bgs.protocol.connection.v1.BindRequest.imported_service) + return imported_service_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService >& +BindRequest::imported_service() const { + // @@protoc_insertion_point(field_list:bgs.protocol.connection.v1.BindRequest.imported_service) + return imported_service_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService >* +BindRequest::mutable_imported_service() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.connection.v1.BindRequest.imported_service) + return &imported_service_; +} + +// ------------------------------------------------------------------- + +// BindResponse + +// repeated uint32 imported_service_id = 1 [packed = true, deprecated = true]; +inline int BindResponse::imported_service_id_size() const { + return imported_service_id_.size(); +} +inline void BindResponse::clear_imported_service_id() { + imported_service_id_.Clear(); +} +inline ::google::protobuf::uint32 BindResponse::imported_service_id(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.BindResponse.imported_service_id) + return imported_service_id_.Get(index); +} +inline void BindResponse::set_imported_service_id(int index, ::google::protobuf::uint32 value) { + imported_service_id_.Set(index, value); + // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.BindResponse.imported_service_id) +} +inline void BindResponse::add_imported_service_id(::google::protobuf::uint32 value) { + imported_service_id_.Add(value); + // @@protoc_insertion_point(field_add:bgs.protocol.connection.v1.BindResponse.imported_service_id) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +BindResponse::imported_service_id() const { + // @@protoc_insertion_point(field_list:bgs.protocol.connection.v1.BindResponse.imported_service_id) + return imported_service_id_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +BindResponse::mutable_imported_service_id() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.connection.v1.BindResponse.imported_service_id) + return &imported_service_id_; +} + +// ------------------------------------------------------------------- + +// EchoRequest + +// optional fixed64 time = 1; +inline bool EchoRequest::has_time() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void EchoRequest::set_has_time() { + _has_bits_[0] |= 0x00000001u; +} +inline void EchoRequest::clear_has_time() { + _has_bits_[0] &= ~0x00000001u; +} +inline void EchoRequest::clear_time() { + time_ = GOOGLE_ULONGLONG(0); + clear_has_time(); +} +inline ::google::protobuf::uint64 EchoRequest::time() const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.EchoRequest.time) + return time_; +} +inline void EchoRequest::set_time(::google::protobuf::uint64 value) { + set_has_time(); + time_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.EchoRequest.time) +} + +// optional bool network_only = 2 [default = false]; +inline bool EchoRequest::has_network_only() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void EchoRequest::set_has_network_only() { + _has_bits_[0] |= 0x00000002u; +} +inline void EchoRequest::clear_has_network_only() { + _has_bits_[0] &= ~0x00000002u; +} +inline void EchoRequest::clear_network_only() { + network_only_ = false; + clear_has_network_only(); +} +inline bool EchoRequest::network_only() const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.EchoRequest.network_only) + return network_only_; +} +inline void EchoRequest::set_network_only(bool value) { + set_has_network_only(); + network_only_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.EchoRequest.network_only) +} + +// optional bytes payload = 3; +inline bool EchoRequest::has_payload() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void EchoRequest::set_has_payload() { + _has_bits_[0] |= 0x00000004u; +} +inline void EchoRequest::clear_has_payload() { + _has_bits_[0] &= ~0x00000004u; +} +inline void EchoRequest::clear_payload() { + if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + payload_->clear(); + } + clear_has_payload(); +} +inline const ::std::string& EchoRequest::payload() const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.EchoRequest.payload) + return *payload_; +} +inline void EchoRequest::set_payload(const ::std::string& value) { + set_has_payload(); + if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + payload_ = new ::std::string; + } + payload_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.EchoRequest.payload) +} +inline void EchoRequest::set_payload(const char* value) { + set_has_payload(); + if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + payload_ = new ::std::string; + } + payload_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.connection.v1.EchoRequest.payload) +} +inline void EchoRequest::set_payload(const void* value, size_t size) { + set_has_payload(); + if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + payload_ = new ::std::string; + } + payload_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.connection.v1.EchoRequest.payload) +} +inline ::std::string* EchoRequest::mutable_payload() { + set_has_payload(); + if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + payload_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.EchoRequest.payload) + return payload_; +} +inline ::std::string* EchoRequest::release_payload() { + clear_has_payload(); + if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = payload_; + payload_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void EchoRequest::set_allocated_payload(::std::string* payload) { + if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete payload_; + } + if (payload) { + set_has_payload(); + payload_ = payload; + } else { + clear_has_payload(); + payload_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.connection.v1.EchoRequest.payload) +} + +// ------------------------------------------------------------------- + +// EchoResponse + +// optional fixed64 time = 1; +inline bool EchoResponse::has_time() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void EchoResponse::set_has_time() { + _has_bits_[0] |= 0x00000001u; +} +inline void EchoResponse::clear_has_time() { + _has_bits_[0] &= ~0x00000001u; +} +inline void EchoResponse::clear_time() { + time_ = GOOGLE_ULONGLONG(0); + clear_has_time(); +} +inline ::google::protobuf::uint64 EchoResponse::time() const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.EchoResponse.time) + return time_; +} +inline void EchoResponse::set_time(::google::protobuf::uint64 value) { + set_has_time(); + time_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.EchoResponse.time) +} + +// optional bytes payload = 2; +inline bool EchoResponse::has_payload() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void EchoResponse::set_has_payload() { + _has_bits_[0] |= 0x00000002u; +} +inline void EchoResponse::clear_has_payload() { + _has_bits_[0] &= ~0x00000002u; +} +inline void EchoResponse::clear_payload() { + if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + payload_->clear(); + } + clear_has_payload(); +} +inline const ::std::string& EchoResponse::payload() const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.EchoResponse.payload) + return *payload_; +} +inline void EchoResponse::set_payload(const ::std::string& value) { + set_has_payload(); + if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + payload_ = new ::std::string; + } + payload_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.EchoResponse.payload) +} +inline void EchoResponse::set_payload(const char* value) { + set_has_payload(); + if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + payload_ = new ::std::string; + } + payload_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.connection.v1.EchoResponse.payload) +} +inline void EchoResponse::set_payload(const void* value, size_t size) { + set_has_payload(); + if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + payload_ = new ::std::string; + } + payload_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.connection.v1.EchoResponse.payload) +} +inline ::std::string* EchoResponse::mutable_payload() { + set_has_payload(); + if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + payload_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.EchoResponse.payload) + return payload_; +} +inline ::std::string* EchoResponse::release_payload() { + clear_has_payload(); + if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = payload_; + payload_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void EchoResponse::set_allocated_payload(::std::string* payload) { + if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete payload_; + } + if (payload) { + set_has_payload(); + payload_ = payload; + } else { + clear_has_payload(); + payload_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.connection.v1.EchoResponse.payload) +} + +// ------------------------------------------------------------------- + +// DisconnectRequest + +// required uint32 error_code = 1; +inline bool DisconnectRequest::has_error_code() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void DisconnectRequest::set_has_error_code() { + _has_bits_[0] |= 0x00000001u; +} +inline void DisconnectRequest::clear_has_error_code() { + _has_bits_[0] &= ~0x00000001u; +} +inline void DisconnectRequest::clear_error_code() { + error_code_ = 0u; + clear_has_error_code(); +} +inline ::google::protobuf::uint32 DisconnectRequest::error_code() const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.DisconnectRequest.error_code) + return error_code_; +} +inline void DisconnectRequest::set_error_code(::google::protobuf::uint32 value) { + set_has_error_code(); + error_code_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.DisconnectRequest.error_code) +} + +// ------------------------------------------------------------------- + +// DisconnectNotification + +// required uint32 error_code = 1; +inline bool DisconnectNotification::has_error_code() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void DisconnectNotification::set_has_error_code() { + _has_bits_[0] |= 0x00000001u; +} +inline void DisconnectNotification::clear_has_error_code() { + _has_bits_[0] &= ~0x00000001u; +} +inline void DisconnectNotification::clear_error_code() { + error_code_ = 0u; + clear_has_error_code(); +} +inline ::google::protobuf::uint32 DisconnectNotification::error_code() const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.DisconnectNotification.error_code) + return error_code_; +} +inline void DisconnectNotification::set_error_code(::google::protobuf::uint32 value) { + set_has_error_code(); + error_code_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.DisconnectNotification.error_code) +} + +// optional string reason = 2; +inline bool DisconnectNotification::has_reason() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void DisconnectNotification::set_has_reason() { + _has_bits_[0] |= 0x00000002u; +} +inline void DisconnectNotification::clear_has_reason() { + _has_bits_[0] &= ~0x00000002u; +} +inline void DisconnectNotification::clear_reason() { + if (reason_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + reason_->clear(); + } + clear_has_reason(); +} +inline const ::std::string& DisconnectNotification::reason() const { + // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.DisconnectNotification.reason) + return *reason_; +} +inline void DisconnectNotification::set_reason(const ::std::string& value) { + set_has_reason(); + if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + reason_ = new ::std::string; + } + reason_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.DisconnectNotification.reason) +} +inline void DisconnectNotification::set_reason(const char* value) { + set_has_reason(); + if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + reason_ = new ::std::string; + } + reason_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.connection.v1.DisconnectNotification.reason) +} +inline void DisconnectNotification::set_reason(const char* value, size_t size) { + set_has_reason(); + if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + reason_ = new ::std::string; + } + reason_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.connection.v1.DisconnectNotification.reason) +} +inline ::std::string* DisconnectNotification::mutable_reason() { + set_has_reason(); + if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + reason_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.DisconnectNotification.reason) + return reason_; +} +inline ::std::string* DisconnectNotification::release_reason() { + clear_has_reason(); + if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = reason_; + reason_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void DisconnectNotification::set_allocated_reason(::std::string* reason) { + if (reason_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete reason_; + } + if (reason) { + set_has_reason(); + reason_ = reason; + } else { + clear_has_reason(); + reason_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.connection.v1.DisconnectNotification.reason) +} + +// ------------------------------------------------------------------- + +// EncryptRequest + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace connection +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_connection_5fservice_2eproto__INCLUDED diff --git a/src/server/proto/Client/content_handle_types.pb.cc b/src/server/proto/Client/content_handle_types.pb.cc new file mode 100644 index 00000000000..6f480167d10 --- /dev/null +++ b/src/server/proto/Client/content_handle_types.pb.cc @@ -0,0 +1,496 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: content_handle_types.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "content_handle_types.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { + +namespace { + +const ::google::protobuf::Descriptor* ContentHandle_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ContentHandle_reflection_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_content_5fhandle_5ftypes_2eproto() { + protobuf_AddDesc_content_5fhandle_5ftypes_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "content_handle_types.proto"); + GOOGLE_CHECK(file != NULL); + ContentHandle_descriptor_ = file->message_type(0); + static const int ContentHandle_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentHandle, region_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentHandle, usage_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentHandle, hash_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentHandle, proto_url_), + }; + ContentHandle_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ContentHandle_descriptor_, + ContentHandle::default_instance_, + ContentHandle_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentHandle, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentHandle, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ContentHandle)); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_content_5fhandle_5ftypes_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ContentHandle_descriptor_, &ContentHandle::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_content_5fhandle_5ftypes_2eproto() { + delete ContentHandle::default_instance_; + delete ContentHandle_reflection_; +} + +void protobuf_AddDesc_content_5fhandle_5ftypes_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\032content_handle_types.proto\022\014bgs.protoc" + "ol\"O\n\rContentHandle\022\016\n\006region\030\001 \002(\007\022\r\n\005u" + "sage\030\002 \002(\007\022\014\n\004hash\030\003 \002(\014\022\021\n\tproto_url\030\004 " + "\001(\tB%\n\rbnet.protocolB\022ContentHandleProto" + "H\001", 162); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "content_handle_types.proto", &protobuf_RegisterTypes); + ContentHandle::default_instance_ = new ContentHandle(); + ContentHandle::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_content_5fhandle_5ftypes_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_content_5fhandle_5ftypes_2eproto { + StaticDescriptorInitializer_content_5fhandle_5ftypes_2eproto() { + protobuf_AddDesc_content_5fhandle_5ftypes_2eproto(); + } +} static_descriptor_initializer_content_5fhandle_5ftypes_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int ContentHandle::kRegionFieldNumber; +const int ContentHandle::kUsageFieldNumber; +const int ContentHandle::kHashFieldNumber; +const int ContentHandle::kProtoUrlFieldNumber; +#endif // !_MSC_VER + +ContentHandle::ContentHandle() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.ContentHandle) +} + +void ContentHandle::InitAsDefaultInstance() { +} + +ContentHandle::ContentHandle(const ContentHandle& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.ContentHandle) +} + +void ContentHandle::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + region_ = 0u; + usage_ = 0u; + hash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + proto_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ContentHandle::~ContentHandle() { + // @@protoc_insertion_point(destructor:bgs.protocol.ContentHandle) + SharedDtor(); +} + +void ContentHandle::SharedDtor() { + if (hash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete hash_; + } + if (proto_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete proto_url_; + } + if (this != default_instance_) { + } +} + +void ContentHandle::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ContentHandle::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ContentHandle_descriptor_; +} + +const ContentHandle& ContentHandle::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_content_5fhandle_5ftypes_2eproto(); + return *default_instance_; +} + +ContentHandle* ContentHandle::default_instance_ = NULL; + +ContentHandle* ContentHandle::New() const { + return new ContentHandle; +} + +void ContentHandle::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(region_, usage_); + if (has_hash()) { + if (hash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + hash_->clear(); + } + } + if (has_proto_url()) { + if (proto_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + proto_url_->clear(); + } + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ContentHandle::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.ContentHandle) + 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)) { + // required fixed32 region = 1; + case 1: { + if (tag == 13) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, ®ion_))); + set_has_region(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(21)) goto parse_usage; + break; + } + + // required fixed32 usage = 2; + case 2: { + if (tag == 21) { + parse_usage: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &usage_))); + set_has_usage(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_hash; + break; + } + + // required bytes hash = 3; + case 3: { + if (tag == 26) { + parse_hash: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_hash())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_proto_url; + break; + } + + // optional string proto_url = 4; + case 4: { + if (tag == 34) { + parse_proto_url: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_proto_url())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->proto_url().data(), this->proto_url().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "proto_url"); + } 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:bgs.protocol.ContentHandle) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.ContentHandle) + return false; +#undef DO_ +} + +void ContentHandle::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.ContentHandle) + // required fixed32 region = 1; + if (has_region()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->region(), output); + } + + // required fixed32 usage = 2; + if (has_usage()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->usage(), output); + } + + // required bytes hash = 3; + if (has_hash()) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 3, this->hash(), output); + } + + // optional string proto_url = 4; + if (has_proto_url()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->proto_url().data(), this->proto_url().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "proto_url"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 4, this->proto_url(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.ContentHandle) +} + +::google::protobuf::uint8* ContentHandle::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.ContentHandle) + // required fixed32 region = 1; + if (has_region()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->region(), target); + } + + // required fixed32 usage = 2; + if (has_usage()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->usage(), target); + } + + // required bytes hash = 3; + if (has_hash()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 3, this->hash(), target); + } + + // optional string proto_url = 4; + if (has_proto_url()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->proto_url().data(), this->proto_url().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "proto_url"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->proto_url(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.ContentHandle) + return target; +} + +int ContentHandle::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed32 region = 1; + if (has_region()) { + total_size += 1 + 4; + } + + // required fixed32 usage = 2; + if (has_usage()) { + total_size += 1 + 4; + } + + // required bytes hash = 3; + if (has_hash()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->hash()); + } + + // optional string proto_url = 4; + if (has_proto_url()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->proto_url()); + } + + } + 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 ContentHandle::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ContentHandle* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ContentHandle::MergeFrom(const ContentHandle& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_region()) { + set_region(from.region()); + } + if (from.has_usage()) { + set_usage(from.usage()); + } + if (from.has_hash()) { + set_hash(from.hash()); + } + if (from.has_proto_url()) { + set_proto_url(from.proto_url()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ContentHandle::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ContentHandle::CopyFrom(const ContentHandle& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ContentHandle::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + return true; +} + +void ContentHandle::Swap(ContentHandle* other) { + if (other != this) { + std::swap(region_, other->region_); + std::swap(usage_, other->usage_); + std::swap(hash_, other->hash_); + std::swap(proto_url_, other->proto_url_); + 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 ContentHandle::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ContentHandle_descriptor_; + metadata.reflection = ContentHandle_reflection_; + return metadata; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/content_handle_types.pb.h b/src/server/proto/Client/content_handle_types.pb.h new file mode 100644 index 00000000000..d2f69e1329f --- /dev/null +++ b/src/server/proto/Client/content_handle_types.pb.h @@ -0,0 +1,386 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: content_handle_types.proto + +#ifndef PROTOBUF_content_5fhandle_5ftypes_2eproto__INCLUDED +#define PROTOBUF_content_5fhandle_5ftypes_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include "Define.h" // for TRINITY_SHARED_API +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_content_5fhandle_5ftypes_2eproto(); +void protobuf_AssignDesc_content_5fhandle_5ftypes_2eproto(); +void protobuf_ShutdownFile_content_5fhandle_5ftypes_2eproto(); + +class ContentHandle; + +// =================================================================== + +class TC_SHARED_API ContentHandle : public ::google::protobuf::Message { + public: + ContentHandle(); + virtual ~ContentHandle(); + + ContentHandle(const ContentHandle& from); + + inline ContentHandle& operator=(const ContentHandle& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ContentHandle& default_instance(); + + void Swap(ContentHandle* other); + + // implements Message ---------------------------------------------- + + ContentHandle* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ContentHandle& from); + void MergeFrom(const ContentHandle& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed32 region = 1; + inline bool has_region() const; + inline void clear_region(); + static const int kRegionFieldNumber = 1; + inline ::google::protobuf::uint32 region() const; + inline void set_region(::google::protobuf::uint32 value); + + // required fixed32 usage = 2; + inline bool has_usage() const; + inline void clear_usage(); + static const int kUsageFieldNumber = 2; + inline ::google::protobuf::uint32 usage() const; + inline void set_usage(::google::protobuf::uint32 value); + + // required bytes hash = 3; + inline bool has_hash() const; + inline void clear_hash(); + static const int kHashFieldNumber = 3; + inline const ::std::string& hash() const; + inline void set_hash(const ::std::string& value); + inline void set_hash(const char* value); + inline void set_hash(const void* value, size_t size); + inline ::std::string* mutable_hash(); + inline ::std::string* release_hash(); + inline void set_allocated_hash(::std::string* hash); + + // optional string proto_url = 4; + inline bool has_proto_url() const; + inline void clear_proto_url(); + static const int kProtoUrlFieldNumber = 4; + inline const ::std::string& proto_url() const; + inline void set_proto_url(const ::std::string& value); + inline void set_proto_url(const char* value); + inline void set_proto_url(const char* value, size_t size); + inline ::std::string* mutable_proto_url(); + inline ::std::string* release_proto_url(); + inline void set_allocated_proto_url(::std::string* proto_url); + + // @@protoc_insertion_point(class_scope:bgs.protocol.ContentHandle) + private: + inline void set_has_region(); + inline void clear_has_region(); + inline void set_has_usage(); + inline void clear_has_usage(); + inline void set_has_hash(); + inline void clear_has_hash(); + inline void set_has_proto_url(); + inline void clear_has_proto_url(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 region_; + ::google::protobuf::uint32 usage_; + ::std::string* hash_; + ::std::string* proto_url_; + friend void TC_SHARED_API protobuf_AddDesc_content_5fhandle_5ftypes_2eproto(); + friend void protobuf_AssignDesc_content_5fhandle_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_content_5fhandle_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static ContentHandle* default_instance_; +}; +// =================================================================== + + +// =================================================================== + + +// =================================================================== + +// ContentHandle + +// required fixed32 region = 1; +inline bool ContentHandle::has_region() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ContentHandle::set_has_region() { + _has_bits_[0] |= 0x00000001u; +} +inline void ContentHandle::clear_has_region() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ContentHandle::clear_region() { + region_ = 0u; + clear_has_region(); +} +inline ::google::protobuf::uint32 ContentHandle::region() const { + // @@protoc_insertion_point(field_get:bgs.protocol.ContentHandle.region) + return region_; +} +inline void ContentHandle::set_region(::google::protobuf::uint32 value) { + set_has_region(); + region_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.ContentHandle.region) +} + +// required fixed32 usage = 2; +inline bool ContentHandle::has_usage() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ContentHandle::set_has_usage() { + _has_bits_[0] |= 0x00000002u; +} +inline void ContentHandle::clear_has_usage() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ContentHandle::clear_usage() { + usage_ = 0u; + clear_has_usage(); +} +inline ::google::protobuf::uint32 ContentHandle::usage() const { + // @@protoc_insertion_point(field_get:bgs.protocol.ContentHandle.usage) + return usage_; +} +inline void ContentHandle::set_usage(::google::protobuf::uint32 value) { + set_has_usage(); + usage_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.ContentHandle.usage) +} + +// required bytes hash = 3; +inline bool ContentHandle::has_hash() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ContentHandle::set_has_hash() { + _has_bits_[0] |= 0x00000004u; +} +inline void ContentHandle::clear_has_hash() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ContentHandle::clear_hash() { + if (hash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + hash_->clear(); + } + clear_has_hash(); +} +inline const ::std::string& ContentHandle::hash() const { + // @@protoc_insertion_point(field_get:bgs.protocol.ContentHandle.hash) + return *hash_; +} +inline void ContentHandle::set_hash(const ::std::string& value) { + set_has_hash(); + if (hash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + hash_ = new ::std::string; + } + hash_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.ContentHandle.hash) +} +inline void ContentHandle::set_hash(const char* value) { + set_has_hash(); + if (hash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + hash_ = new ::std::string; + } + hash_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.ContentHandle.hash) +} +inline void ContentHandle::set_hash(const void* value, size_t size) { + set_has_hash(); + if (hash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + hash_ = new ::std::string; + } + hash_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.ContentHandle.hash) +} +inline ::std::string* ContentHandle::mutable_hash() { + set_has_hash(); + if (hash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + hash_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.ContentHandle.hash) + return hash_; +} +inline ::std::string* ContentHandle::release_hash() { + clear_has_hash(); + if (hash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = hash_; + hash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ContentHandle::set_allocated_hash(::std::string* hash) { + if (hash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete hash_; + } + if (hash) { + set_has_hash(); + hash_ = hash; + } else { + clear_has_hash(); + hash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.ContentHandle.hash) +} + +// optional string proto_url = 4; +inline bool ContentHandle::has_proto_url() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void ContentHandle::set_has_proto_url() { + _has_bits_[0] |= 0x00000008u; +} +inline void ContentHandle::clear_has_proto_url() { + _has_bits_[0] &= ~0x00000008u; +} +inline void ContentHandle::clear_proto_url() { + if (proto_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + proto_url_->clear(); + } + clear_has_proto_url(); +} +inline const ::std::string& ContentHandle::proto_url() const { + // @@protoc_insertion_point(field_get:bgs.protocol.ContentHandle.proto_url) + return *proto_url_; +} +inline void ContentHandle::set_proto_url(const ::std::string& value) { + set_has_proto_url(); + if (proto_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + proto_url_ = new ::std::string; + } + proto_url_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.ContentHandle.proto_url) +} +inline void ContentHandle::set_proto_url(const char* value) { + set_has_proto_url(); + if (proto_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + proto_url_ = new ::std::string; + } + proto_url_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.ContentHandle.proto_url) +} +inline void ContentHandle::set_proto_url(const char* value, size_t size) { + set_has_proto_url(); + if (proto_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + proto_url_ = new ::std::string; + } + proto_url_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.ContentHandle.proto_url) +} +inline ::std::string* ContentHandle::mutable_proto_url() { + set_has_proto_url(); + if (proto_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + proto_url_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.ContentHandle.proto_url) + return proto_url_; +} +inline ::std::string* ContentHandle::release_proto_url() { + clear_has_proto_url(); + if (proto_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = proto_url_; + proto_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ContentHandle::set_allocated_proto_url(::std::string* proto_url) { + if (proto_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete proto_url_; + } + if (proto_url) { + set_has_proto_url(); + proto_url_ = proto_url; + } else { + clear_has_proto_url(); + proto_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.ContentHandle.proto_url) +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_content_5fhandle_5ftypes_2eproto__INCLUDED diff --git a/src/server/proto/Client/entity_types.pb.cc b/src/server/proto/Client/entity_types.pb.cc new file mode 100644 index 00000000000..29e95bdf0e9 --- /dev/null +++ b/src/server/proto/Client/entity_types.pb.cc @@ -0,0 +1,1177 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: entity_types.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "entity_types.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { + +namespace { + +const ::google::protobuf::Descriptor* EntityId_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + EntityId_reflection_ = NULL; +const ::google::protobuf::Descriptor* Identity_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Identity_reflection_ = NULL; +const ::google::protobuf::Descriptor* AccountInfo_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AccountInfo_reflection_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_entity_5ftypes_2eproto() { + protobuf_AddDesc_entity_5ftypes_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "entity_types.proto"); + GOOGLE_CHECK(file != NULL); + EntityId_descriptor_ = file->message_type(0); + static const int EntityId_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EntityId, high_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EntityId, low_), + }; + EntityId_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + EntityId_descriptor_, + EntityId::default_instance_, + EntityId_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EntityId, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EntityId, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(EntityId)); + Identity_descriptor_ = file->message_type(1); + static const int Identity_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Identity, account_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Identity, game_account_id_), + }; + Identity_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Identity_descriptor_, + Identity::default_instance_, + Identity_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Identity, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Identity, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Identity)); + AccountInfo_descriptor_ = file->message_type(2); + static const int AccountInfo_offsets_[6] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, account_paid_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, country_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, battle_tag_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, manual_review_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, identity_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, account_muted_), + }; + AccountInfo_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AccountInfo_descriptor_, + AccountInfo::default_instance_, + AccountInfo_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AccountInfo)); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_entity_5ftypes_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + EntityId_descriptor_, &EntityId::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Identity_descriptor_, &Identity::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AccountInfo_descriptor_, &AccountInfo::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_entity_5ftypes_2eproto() { + delete EntityId::default_instance_; + delete EntityId_reflection_; + delete Identity::default_instance_; + delete Identity_reflection_; + delete AccountInfo::default_instance_; + delete AccountInfo_reflection_; +} + +void protobuf_AddDesc_entity_5ftypes_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::bgs::protocol::protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\022entity_types.proto\022\014bgs.protocol\032%glob" + "al_extensions/field_options.proto\"1\n\010Ent" + "ityId\022\022\n\004high\030\001 \002(\006B\004\200\265\030\002\022\021\n\003low\030\002 \002(\006B\004" + "\200\265\030\002\"g\n\010Identity\022*\n\naccount_id\030\001 \001(\0132\026.b" + "gs.protocol.EntityId\022/\n\017game_account_id\030" + "\002 \001(\0132\026.bgs.protocol.EntityId\"\273\001\n\013Accoun" + "tInfo\022\033\n\014account_paid\030\001 \001(\010:\005false\022\025\n\nco" + "untry_id\030\002 \001(\007:\0010\022\022\n\nbattle_tag\030\003 \001(\t\022\034\n" + "\rmanual_review\030\004 \001(\010:\005false\022(\n\010identity\030" + "\005 \001(\0132\026.bgs.protocol.Identity\022\034\n\raccount" + "_muted\030\006 \001(\010:\005falseB\036\n\rbnet.protocolB\013En" + "tityProtoH\001", 451); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "entity_types.proto", &protobuf_RegisterTypes); + EntityId::default_instance_ = new EntityId(); + Identity::default_instance_ = new Identity(); + AccountInfo::default_instance_ = new AccountInfo(); + EntityId::default_instance_->InitAsDefaultInstance(); + Identity::default_instance_->InitAsDefaultInstance(); + AccountInfo::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_entity_5ftypes_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_entity_5ftypes_2eproto { + StaticDescriptorInitializer_entity_5ftypes_2eproto() { + protobuf_AddDesc_entity_5ftypes_2eproto(); + } +} static_descriptor_initializer_entity_5ftypes_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int EntityId::kHighFieldNumber; +const int EntityId::kLowFieldNumber; +#endif // !_MSC_VER + +EntityId::EntityId() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.EntityId) +} + +void EntityId::InitAsDefaultInstance() { +} + +EntityId::EntityId(const EntityId& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.EntityId) +} + +void EntityId::SharedCtor() { + _cached_size_ = 0; + high_ = GOOGLE_ULONGLONG(0); + low_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +EntityId::~EntityId() { + // @@protoc_insertion_point(destructor:bgs.protocol.EntityId) + SharedDtor(); +} + +void EntityId::SharedDtor() { + if (this != default_instance_) { + } +} + +void EntityId::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* EntityId::descriptor() { + protobuf_AssignDescriptorsOnce(); + return EntityId_descriptor_; +} + +const EntityId& EntityId::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_entity_5ftypes_2eproto(); + return *default_instance_; +} + +EntityId* EntityId::default_instance_ = NULL; + +EntityId* EntityId::New() const { + return new EntityId; +} + +void EntityId::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(high_, low_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool EntityId::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.EntityId) + 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)) { + // required fixed64 high = 1; + case 1: { + if (tag == 9) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &high_))); + set_has_high(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(17)) goto parse_low; + break; + } + + // required fixed64 low = 2; + case 2: { + if (tag == 17) { + parse_low: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &low_))); + set_has_low(); + } 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:bgs.protocol.EntityId) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.EntityId) + return false; +#undef DO_ +} + +void EntityId::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.EntityId) + // required fixed64 high = 1; + if (has_high()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->high(), output); + } + + // required fixed64 low = 2; + if (has_low()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->low(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.EntityId) +} + +::google::protobuf::uint8* EntityId::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.EntityId) + // required fixed64 high = 1; + if (has_high()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->high(), target); + } + + // required fixed64 low = 2; + if (has_low()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->low(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.EntityId) + return target; +} + +int EntityId::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed64 high = 1; + if (has_high()) { + total_size += 1 + 8; + } + + // required fixed64 low = 2; + if (has_low()) { + total_size += 1 + 8; + } + + } + 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 EntityId::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const EntityId* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void EntityId::MergeFrom(const EntityId& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_high()) { + set_high(from.high()); + } + if (from.has_low()) { + set_low(from.low()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void EntityId::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void EntityId::CopyFrom(const EntityId& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool EntityId::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void EntityId::Swap(EntityId* other) { + if (other != this) { + std::swap(high_, other->high_); + std::swap(low_, other->low_); + 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 EntityId::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = EntityId_descriptor_; + metadata.reflection = EntityId_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int Identity::kAccountIdFieldNumber; +const int Identity::kGameAccountIdFieldNumber; +#endif // !_MSC_VER + +Identity::Identity() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.Identity) +} + +void Identity::InitAsDefaultInstance() { + account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +Identity::Identity(const Identity& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.Identity) +} + +void Identity::SharedCtor() { + _cached_size_ = 0; + account_id_ = NULL; + game_account_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Identity::~Identity() { + // @@protoc_insertion_point(destructor:bgs.protocol.Identity) + SharedDtor(); +} + +void Identity::SharedDtor() { + if (this != default_instance_) { + delete account_id_; + delete game_account_id_; + } +} + +void Identity::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Identity::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Identity_descriptor_; +} + +const Identity& Identity::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_entity_5ftypes_2eproto(); + return *default_instance_; +} + +Identity* Identity::default_instance_ = NULL; + +Identity* Identity::New() const { + return new Identity; +} + +void Identity::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_account_id()) { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_game_account_id()) { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Identity::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.Identity) + 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 .bgs.protocol.EntityId account_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_game_account_id; + break; + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + case 2: { + if (tag == 18) { + parse_game_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account_id())); + } 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:bgs.protocol.Identity) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.Identity) + return false; +#undef DO_ +} + +void Identity::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.Identity) + // optional .bgs.protocol.EntityId account_id = 1; + if (has_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->account_id(), output); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->game_account_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.Identity) +} + +::google::protobuf::uint8* Identity::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.Identity) + // optional .bgs.protocol.EntityId account_id = 1; + if (has_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->account_id(), target); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->game_account_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.Identity) + return target; +} + +int Identity::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId account_id = 1; + if (has_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account_id()); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void Identity::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Identity* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Identity::MergeFrom(const Identity& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_account_id()) { + mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id()); + } + if (from.has_game_account_id()) { + mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Identity::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Identity::CopyFrom(const Identity& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Identity::IsInitialized() const { + + if (has_account_id()) { + if (!this->account_id().IsInitialized()) return false; + } + if (has_game_account_id()) { + if (!this->game_account_id().IsInitialized()) return false; + } + return true; +} + +void Identity::Swap(Identity* other) { + if (other != this) { + std::swap(account_id_, other->account_id_); + std::swap(game_account_id_, other->game_account_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata Identity::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Identity_descriptor_; + metadata.reflection = Identity_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AccountInfo::kAccountPaidFieldNumber; +const int AccountInfo::kCountryIdFieldNumber; +const int AccountInfo::kBattleTagFieldNumber; +const int AccountInfo::kManualReviewFieldNumber; +const int AccountInfo::kIdentityFieldNumber; +const int AccountInfo::kAccountMutedFieldNumber; +#endif // !_MSC_VER + +AccountInfo::AccountInfo() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.AccountInfo) +} + +void AccountInfo::InitAsDefaultInstance() { + identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance()); +} + +AccountInfo::AccountInfo(const AccountInfo& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.AccountInfo) +} + +void AccountInfo::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + account_paid_ = false; + country_id_ = 0u; + battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + manual_review_ = false; + identity_ = NULL; + account_muted_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AccountInfo::~AccountInfo() { + // @@protoc_insertion_point(destructor:bgs.protocol.AccountInfo) + SharedDtor(); +} + +void AccountInfo::SharedDtor() { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete battle_tag_; + } + if (this != default_instance_) { + delete identity_; + } +} + +void AccountInfo::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AccountInfo::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AccountInfo_descriptor_; +} + +const AccountInfo& AccountInfo::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_entity_5ftypes_2eproto(); + return *default_instance_; +} + +AccountInfo* AccountInfo::default_instance_ = NULL; + +AccountInfo* AccountInfo::New() const { + return new AccountInfo; +} + +void AccountInfo::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(country_id_, account_muted_); + if (has_battle_tag()) { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_->clear(); + } + } + if (has_identity()) { + if (identity_ != NULL) identity_->::bgs::protocol::Identity::Clear(); + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AccountInfo::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.AccountInfo) + 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 account_paid = 1 [default = false]; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &account_paid_))); + set_has_account_paid(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(21)) goto parse_country_id; + break; + } + + // optional fixed32 country_id = 2 [default = 0]; + case 2: { + if (tag == 21) { + parse_country_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &country_id_))); + set_has_country_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_battle_tag; + break; + } + + // optional string battle_tag = 3; + case 3: { + if (tag == 26) { + parse_battle_tag: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_battle_tag())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->battle_tag().data(), this->battle_tag().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "battle_tag"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_manual_review; + break; + } + + // optional bool manual_review = 4 [default = false]; + case 4: { + if (tag == 32) { + parse_manual_review: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &manual_review_))); + set_has_manual_review(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_identity; + break; + } + + // optional .bgs.protocol.Identity identity = 5; + case 5: { + if (tag == 42) { + parse_identity: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_identity())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_account_muted; + break; + } + + // optional bool account_muted = 6 [default = false]; + case 6: { + if (tag == 48) { + parse_account_muted: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &account_muted_))); + set_has_account_muted(); + } 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:bgs.protocol.AccountInfo) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.AccountInfo) + return false; +#undef DO_ +} + +void AccountInfo::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.AccountInfo) + // optional bool account_paid = 1 [default = false]; + if (has_account_paid()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->account_paid(), output); + } + + // optional fixed32 country_id = 2 [default = 0]; + if (has_country_id()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->country_id(), output); + } + + // optional string battle_tag = 3; + if (has_battle_tag()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->battle_tag().data(), this->battle_tag().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "battle_tag"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->battle_tag(), output); + } + + // optional bool manual_review = 4 [default = false]; + if (has_manual_review()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->manual_review(), output); + } + + // optional .bgs.protocol.Identity identity = 5; + if (has_identity()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, this->identity(), output); + } + + // optional bool account_muted = 6 [default = false]; + if (has_account_muted()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->account_muted(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.AccountInfo) +} + +::google::protobuf::uint8* AccountInfo::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.AccountInfo) + // optional bool account_paid = 1 [default = false]; + if (has_account_paid()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->account_paid(), target); + } + + // optional fixed32 country_id = 2 [default = 0]; + if (has_country_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->country_id(), target); + } + + // optional string battle_tag = 3; + if (has_battle_tag()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->battle_tag().data(), this->battle_tag().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "battle_tag"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->battle_tag(), target); + } + + // optional bool manual_review = 4 [default = false]; + if (has_manual_review()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->manual_review(), target); + } + + // optional .bgs.protocol.Identity identity = 5; + if (has_identity()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 5, this->identity(), target); + } + + // optional bool account_muted = 6 [default = false]; + if (has_account_muted()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->account_muted(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.AccountInfo) + return target; +} + +int AccountInfo::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional bool account_paid = 1 [default = false]; + if (has_account_paid()) { + total_size += 1 + 1; + } + + // optional fixed32 country_id = 2 [default = 0]; + if (has_country_id()) { + total_size += 1 + 4; + } + + // optional string battle_tag = 3; + if (has_battle_tag()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->battle_tag()); + } + + // optional bool manual_review = 4 [default = false]; + if (has_manual_review()) { + total_size += 1 + 1; + } + + // optional .bgs.protocol.Identity identity = 5; + if (has_identity()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->identity()); + } + + // optional bool account_muted = 6 [default = false]; + if (has_account_muted()) { + 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 AccountInfo::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AccountInfo* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AccountInfo::MergeFrom(const AccountInfo& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_account_paid()) { + set_account_paid(from.account_paid()); + } + if (from.has_country_id()) { + set_country_id(from.country_id()); + } + if (from.has_battle_tag()) { + set_battle_tag(from.battle_tag()); + } + if (from.has_manual_review()) { + set_manual_review(from.manual_review()); + } + if (from.has_identity()) { + mutable_identity()->::bgs::protocol::Identity::MergeFrom(from.identity()); + } + if (from.has_account_muted()) { + set_account_muted(from.account_muted()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AccountInfo::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AccountInfo::CopyFrom(const AccountInfo& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AccountInfo::IsInitialized() const { + + if (has_identity()) { + if (!this->identity().IsInitialized()) return false; + } + return true; +} + +void AccountInfo::Swap(AccountInfo* other) { + if (other != this) { + std::swap(account_paid_, other->account_paid_); + std::swap(country_id_, other->country_id_); + std::swap(battle_tag_, other->battle_tag_); + std::swap(manual_review_, other->manual_review_); + std::swap(identity_, other->identity_); + std::swap(account_muted_, other->account_muted_); + 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 AccountInfo::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AccountInfo_descriptor_; + metadata.reflection = AccountInfo_reflection_; + return metadata; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/entity_types.pb.h b/src/server/proto/Client/entity_types.pb.h new file mode 100644 index 00000000000..1b01f75a9dc --- /dev/null +++ b/src/server/proto/Client/entity_types.pb.h @@ -0,0 +1,739 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: entity_types.proto + +#ifndef PROTOBUF_entity_5ftypes_2eproto__INCLUDED +#define PROTOBUF_entity_5ftypes_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include "global_extensions/field_options.pb.h" +#include "Define.h" // for TRINITY_SHARED_API +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_entity_5ftypes_2eproto(); +void protobuf_AssignDesc_entity_5ftypes_2eproto(); +void protobuf_ShutdownFile_entity_5ftypes_2eproto(); + +class EntityId; +class Identity; +class AccountInfo; + +// =================================================================== + +class TC_SHARED_API EntityId : public ::google::protobuf::Message { + public: + EntityId(); + virtual ~EntityId(); + + EntityId(const EntityId& from); + + inline EntityId& operator=(const EntityId& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const EntityId& default_instance(); + + void Swap(EntityId* other); + + // implements Message ---------------------------------------------- + + EntityId* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const EntityId& from); + void MergeFrom(const EntityId& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed64 high = 1; + inline bool has_high() const; + inline void clear_high(); + static const int kHighFieldNumber = 1; + inline ::google::protobuf::uint64 high() const; + inline void set_high(::google::protobuf::uint64 value); + + // required fixed64 low = 2; + inline bool has_low() const; + inline void clear_low(); + static const int kLowFieldNumber = 2; + inline ::google::protobuf::uint64 low() const; + inline void set_low(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.EntityId) + private: + inline void set_has_high(); + inline void clear_has_high(); + inline void set_has_low(); + inline void clear_has_low(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint64 high_; + ::google::protobuf::uint64 low_; + friend void TC_SHARED_API protobuf_AddDesc_entity_5ftypes_2eproto(); + friend void protobuf_AssignDesc_entity_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_entity_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static EntityId* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API Identity : public ::google::protobuf::Message { + public: + Identity(); + virtual ~Identity(); + + Identity(const Identity& from); + + inline Identity& operator=(const Identity& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Identity& default_instance(); + + void Swap(Identity* other); + + // implements Message ---------------------------------------------- + + Identity* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Identity& from); + void MergeFrom(const Identity& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId account_id = 1; + inline bool has_account_id() const; + inline void clear_account_id(); + static const int kAccountIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& account_id() const; + inline ::bgs::protocol::EntityId* mutable_account_id(); + inline ::bgs::protocol::EntityId* release_account_id(); + inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id); + + // optional .bgs.protocol.EntityId game_account_id = 2; + inline bool has_game_account_id() const; + inline void clear_game_account_id(); + static const int kGameAccountIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& game_account_id() const; + inline ::bgs::protocol::EntityId* mutable_game_account_id(); + inline ::bgs::protocol::EntityId* release_game_account_id(); + inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id); + + // @@protoc_insertion_point(class_scope:bgs.protocol.Identity) + private: + inline void set_has_account_id(); + inline void clear_has_account_id(); + inline void set_has_game_account_id(); + inline void clear_has_game_account_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* account_id_; + ::bgs::protocol::EntityId* game_account_id_; + friend void TC_SHARED_API protobuf_AddDesc_entity_5ftypes_2eproto(); + friend void protobuf_AssignDesc_entity_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_entity_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static Identity* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API AccountInfo : public ::google::protobuf::Message { + public: + AccountInfo(); + virtual ~AccountInfo(); + + AccountInfo(const AccountInfo& from); + + inline AccountInfo& operator=(const AccountInfo& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AccountInfo& default_instance(); + + void Swap(AccountInfo* other); + + // implements Message ---------------------------------------------- + + AccountInfo* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AccountInfo& from); + void MergeFrom(const AccountInfo& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional bool account_paid = 1 [default = false]; + inline bool has_account_paid() const; + inline void clear_account_paid(); + static const int kAccountPaidFieldNumber = 1; + inline bool account_paid() const; + inline void set_account_paid(bool value); + + // optional fixed32 country_id = 2 [default = 0]; + inline bool has_country_id() const; + inline void clear_country_id(); + static const int kCountryIdFieldNumber = 2; + inline ::google::protobuf::uint32 country_id() const; + inline void set_country_id(::google::protobuf::uint32 value); + + // optional string battle_tag = 3; + inline bool has_battle_tag() const; + inline void clear_battle_tag(); + static const int kBattleTagFieldNumber = 3; + inline const ::std::string& battle_tag() const; + inline void set_battle_tag(const ::std::string& value); + inline void set_battle_tag(const char* value); + inline void set_battle_tag(const char* value, size_t size); + inline ::std::string* mutable_battle_tag(); + inline ::std::string* release_battle_tag(); + inline void set_allocated_battle_tag(::std::string* battle_tag); + + // optional bool manual_review = 4 [default = false]; + inline bool has_manual_review() const; + inline void clear_manual_review(); + static const int kManualReviewFieldNumber = 4; + inline bool manual_review() const; + inline void set_manual_review(bool value); + + // optional .bgs.protocol.Identity identity = 5; + inline bool has_identity() const; + inline void clear_identity(); + static const int kIdentityFieldNumber = 5; + inline const ::bgs::protocol::Identity& identity() const; + inline ::bgs::protocol::Identity* mutable_identity(); + inline ::bgs::protocol::Identity* release_identity(); + inline void set_allocated_identity(::bgs::protocol::Identity* identity); + + // optional bool account_muted = 6 [default = false]; + inline bool has_account_muted() const; + inline void clear_account_muted(); + static const int kAccountMutedFieldNumber = 6; + inline bool account_muted() const; + inline void set_account_muted(bool value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.AccountInfo) + private: + inline void set_has_account_paid(); + inline void clear_has_account_paid(); + inline void set_has_country_id(); + inline void clear_has_country_id(); + inline void set_has_battle_tag(); + inline void clear_has_battle_tag(); + inline void set_has_manual_review(); + inline void clear_has_manual_review(); + inline void set_has_identity(); + inline void clear_has_identity(); + inline void set_has_account_muted(); + inline void clear_has_account_muted(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* battle_tag_; + ::google::protobuf::uint32 country_id_; + bool account_paid_; + bool manual_review_; + bool account_muted_; + ::bgs::protocol::Identity* identity_; + friend void TC_SHARED_API protobuf_AddDesc_entity_5ftypes_2eproto(); + friend void protobuf_AssignDesc_entity_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_entity_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static AccountInfo* default_instance_; +}; +// =================================================================== + + +// =================================================================== + + +// =================================================================== + +// EntityId + +// required fixed64 high = 1; +inline bool EntityId::has_high() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void EntityId::set_has_high() { + _has_bits_[0] |= 0x00000001u; +} +inline void EntityId::clear_has_high() { + _has_bits_[0] &= ~0x00000001u; +} +inline void EntityId::clear_high() { + high_ = GOOGLE_ULONGLONG(0); + clear_has_high(); +} +inline ::google::protobuf::uint64 EntityId::high() const { + // @@protoc_insertion_point(field_get:bgs.protocol.EntityId.high) + return high_; +} +inline void EntityId::set_high(::google::protobuf::uint64 value) { + set_has_high(); + high_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.EntityId.high) +} + +// required fixed64 low = 2; +inline bool EntityId::has_low() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void EntityId::set_has_low() { + _has_bits_[0] |= 0x00000002u; +} +inline void EntityId::clear_has_low() { + _has_bits_[0] &= ~0x00000002u; +} +inline void EntityId::clear_low() { + low_ = GOOGLE_ULONGLONG(0); + clear_has_low(); +} +inline ::google::protobuf::uint64 EntityId::low() const { + // @@protoc_insertion_point(field_get:bgs.protocol.EntityId.low) + return low_; +} +inline void EntityId::set_low(::google::protobuf::uint64 value) { + set_has_low(); + low_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.EntityId.low) +} + +// ------------------------------------------------------------------- + +// Identity + +// optional .bgs.protocol.EntityId account_id = 1; +inline bool Identity::has_account_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Identity::set_has_account_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void Identity::clear_has_account_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Identity::clear_account_id() { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_account_id(); +} +inline const ::bgs::protocol::EntityId& Identity::account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Identity.account_id) + return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_; +} +inline ::bgs::protocol::EntityId* Identity::mutable_account_id() { + set_has_account_id(); + if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.Identity.account_id) + return account_id_; +} +inline ::bgs::protocol::EntityId* Identity::release_account_id() { + clear_has_account_id(); + ::bgs::protocol::EntityId* temp = account_id_; + account_id_ = NULL; + return temp; +} +inline void Identity::set_allocated_account_id(::bgs::protocol::EntityId* account_id) { + delete account_id_; + account_id_ = account_id; + if (account_id) { + set_has_account_id(); + } else { + clear_has_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Identity.account_id) +} + +// optional .bgs.protocol.EntityId game_account_id = 2; +inline bool Identity::has_game_account_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Identity::set_has_game_account_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void Identity::clear_has_game_account_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Identity::clear_game_account_id() { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_game_account_id(); +} +inline const ::bgs::protocol::EntityId& Identity::game_account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Identity.game_account_id) + return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_; +} +inline ::bgs::protocol::EntityId* Identity::mutable_game_account_id() { + set_has_game_account_id(); + if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.Identity.game_account_id) + return game_account_id_; +} +inline ::bgs::protocol::EntityId* Identity::release_game_account_id() { + clear_has_game_account_id(); + ::bgs::protocol::EntityId* temp = game_account_id_; + game_account_id_ = NULL; + return temp; +} +inline void Identity::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) { + delete game_account_id_; + game_account_id_ = game_account_id; + if (game_account_id) { + set_has_game_account_id(); + } else { + clear_has_game_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Identity.game_account_id) +} + +// ------------------------------------------------------------------- + +// AccountInfo + +// optional bool account_paid = 1 [default = false]; +inline bool AccountInfo::has_account_paid() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AccountInfo::set_has_account_paid() { + _has_bits_[0] |= 0x00000001u; +} +inline void AccountInfo::clear_has_account_paid() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AccountInfo::clear_account_paid() { + account_paid_ = false; + clear_has_account_paid(); +} +inline bool AccountInfo::account_paid() const { + // @@protoc_insertion_point(field_get:bgs.protocol.AccountInfo.account_paid) + return account_paid_; +} +inline void AccountInfo::set_account_paid(bool value) { + set_has_account_paid(); + account_paid_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.AccountInfo.account_paid) +} + +// optional fixed32 country_id = 2 [default = 0]; +inline bool AccountInfo::has_country_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void AccountInfo::set_has_country_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void AccountInfo::clear_has_country_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void AccountInfo::clear_country_id() { + country_id_ = 0u; + clear_has_country_id(); +} +inline ::google::protobuf::uint32 AccountInfo::country_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.AccountInfo.country_id) + return country_id_; +} +inline void AccountInfo::set_country_id(::google::protobuf::uint32 value) { + set_has_country_id(); + country_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.AccountInfo.country_id) +} + +// optional string battle_tag = 3; +inline bool AccountInfo::has_battle_tag() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void AccountInfo::set_has_battle_tag() { + _has_bits_[0] |= 0x00000004u; +} +inline void AccountInfo::clear_has_battle_tag() { + _has_bits_[0] &= ~0x00000004u; +} +inline void AccountInfo::clear_battle_tag() { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_->clear(); + } + clear_has_battle_tag(); +} +inline const ::std::string& AccountInfo::battle_tag() const { + // @@protoc_insertion_point(field_get:bgs.protocol.AccountInfo.battle_tag) + return *battle_tag_; +} +inline void AccountInfo::set_battle_tag(const ::std::string& value) { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + battle_tag_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.AccountInfo.battle_tag) +} +inline void AccountInfo::set_battle_tag(const char* value) { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + battle_tag_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.AccountInfo.battle_tag) +} +inline void AccountInfo::set_battle_tag(const char* value, size_t size) { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + battle_tag_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.AccountInfo.battle_tag) +} +inline ::std::string* AccountInfo::mutable_battle_tag() { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.AccountInfo.battle_tag) + return battle_tag_; +} +inline ::std::string* AccountInfo::release_battle_tag() { + clear_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = battle_tag_; + battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void AccountInfo::set_allocated_battle_tag(::std::string* battle_tag) { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete battle_tag_; + } + if (battle_tag) { + set_has_battle_tag(); + battle_tag_ = battle_tag; + } else { + clear_has_battle_tag(); + battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.AccountInfo.battle_tag) +} + +// optional bool manual_review = 4 [default = false]; +inline bool AccountInfo::has_manual_review() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void AccountInfo::set_has_manual_review() { + _has_bits_[0] |= 0x00000008u; +} +inline void AccountInfo::clear_has_manual_review() { + _has_bits_[0] &= ~0x00000008u; +} +inline void AccountInfo::clear_manual_review() { + manual_review_ = false; + clear_has_manual_review(); +} +inline bool AccountInfo::manual_review() const { + // @@protoc_insertion_point(field_get:bgs.protocol.AccountInfo.manual_review) + return manual_review_; +} +inline void AccountInfo::set_manual_review(bool value) { + set_has_manual_review(); + manual_review_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.AccountInfo.manual_review) +} + +// optional .bgs.protocol.Identity identity = 5; +inline bool AccountInfo::has_identity() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void AccountInfo::set_has_identity() { + _has_bits_[0] |= 0x00000010u; +} +inline void AccountInfo::clear_has_identity() { + _has_bits_[0] &= ~0x00000010u; +} +inline void AccountInfo::clear_identity() { + if (identity_ != NULL) identity_->::bgs::protocol::Identity::Clear(); + clear_has_identity(); +} +inline const ::bgs::protocol::Identity& AccountInfo::identity() const { + // @@protoc_insertion_point(field_get:bgs.protocol.AccountInfo.identity) + return identity_ != NULL ? *identity_ : *default_instance_->identity_; +} +inline ::bgs::protocol::Identity* AccountInfo::mutable_identity() { + set_has_identity(); + if (identity_ == NULL) identity_ = new ::bgs::protocol::Identity; + // @@protoc_insertion_point(field_mutable:bgs.protocol.AccountInfo.identity) + return identity_; +} +inline ::bgs::protocol::Identity* AccountInfo::release_identity() { + clear_has_identity(); + ::bgs::protocol::Identity* temp = identity_; + identity_ = NULL; + return temp; +} +inline void AccountInfo::set_allocated_identity(::bgs::protocol::Identity* identity) { + delete identity_; + identity_ = identity; + if (identity) { + set_has_identity(); + } else { + clear_has_identity(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.AccountInfo.identity) +} + +// optional bool account_muted = 6 [default = false]; +inline bool AccountInfo::has_account_muted() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void AccountInfo::set_has_account_muted() { + _has_bits_[0] |= 0x00000020u; +} +inline void AccountInfo::clear_has_account_muted() { + _has_bits_[0] &= ~0x00000020u; +} +inline void AccountInfo::clear_account_muted() { + account_muted_ = false; + clear_has_account_muted(); +} +inline bool AccountInfo::account_muted() const { + // @@protoc_insertion_point(field_get:bgs.protocol.AccountInfo.account_muted) + return account_muted_; +} +inline void AccountInfo::set_account_muted(bool value) { + set_has_account_muted(); + account_muted_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.AccountInfo.account_muted) +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_entity_5ftypes_2eproto__INCLUDED diff --git a/src/server/proto/Client/friends_service.pb.cc b/src/server/proto/Client/friends_service.pb.cc new file mode 100644 index 00000000000..73e19f22339 --- /dev/null +++ b/src/server/proto/Client/friends_service.pb.cc @@ -0,0 +1,5081 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: friends_service.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "friends_service.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +#include "BattlenetRpcErrorCodes.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { +namespace friends { +namespace v1 { + +namespace { + +const ::google::protobuf::Descriptor* SubscribeRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SubscribeRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* SubscribeResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SubscribeResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* UnsubscribeRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + UnsubscribeRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* GenericFriendRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GenericFriendRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* GenericFriendResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GenericFriendResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* AssignRoleRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AssignRoleRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* ViewFriendsRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ViewFriendsRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* ViewFriendsResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ViewFriendsResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* UpdateFriendStateRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + UpdateFriendStateRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* FriendNotification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + FriendNotification_reflection_ = NULL; +const ::google::protobuf::Descriptor* UpdateFriendStateNotification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + UpdateFriendStateNotification_reflection_ = NULL; +const ::google::protobuf::Descriptor* InvitationNotification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + InvitationNotification_reflection_ = NULL; +const ::google::protobuf::ServiceDescriptor* FriendsService_descriptor_ = NULL; +const ::google::protobuf::ServiceDescriptor* FriendsListener_descriptor_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_friends_5fservice_2eproto() { + protobuf_AddDesc_friends_5fservice_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "friends_service.proto"); + GOOGLE_CHECK(file != NULL); + SubscribeRequest_descriptor_ = file->message_type(0); + static const int SubscribeRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, object_id_), + }; + SubscribeRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + SubscribeRequest_descriptor_, + SubscribeRequest::default_instance_, + SubscribeRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(SubscribeRequest)); + SubscribeResponse_descriptor_ = file->message_type(1); + static const int SubscribeResponse_offsets_[7] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, max_friends_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, max_received_invitations_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, max_sent_invitations_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, role_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, friends_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, sent_invitations_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, received_invitations_), + }; + SubscribeResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + SubscribeResponse_descriptor_, + SubscribeResponse::default_instance_, + SubscribeResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(SubscribeResponse)); + UnsubscribeRequest_descriptor_ = file->message_type(2); + static const int UnsubscribeRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, object_id_), + }; + UnsubscribeRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + UnsubscribeRequest_descriptor_, + UnsubscribeRequest::default_instance_, + UnsubscribeRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(UnsubscribeRequest)); + GenericFriendRequest_descriptor_ = file->message_type(3); + static const int GenericFriendRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericFriendRequest, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericFriendRequest, target_id_), + }; + GenericFriendRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GenericFriendRequest_descriptor_, + GenericFriendRequest::default_instance_, + GenericFriendRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericFriendRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericFriendRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GenericFriendRequest)); + GenericFriendResponse_descriptor_ = file->message_type(4); + static const int GenericFriendResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericFriendResponse, target_friend_), + }; + GenericFriendResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GenericFriendResponse_descriptor_, + GenericFriendResponse::default_instance_, + GenericFriendResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericFriendResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericFriendResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GenericFriendResponse)); + AssignRoleRequest_descriptor_ = file->message_type(5); + static const int AssignRoleRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AssignRoleRequest, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AssignRoleRequest, target_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AssignRoleRequest, role_), + }; + AssignRoleRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AssignRoleRequest_descriptor_, + AssignRoleRequest::default_instance_, + AssignRoleRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AssignRoleRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AssignRoleRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AssignRoleRequest)); + ViewFriendsRequest_descriptor_ = file->message_type(6); + static const int ViewFriendsRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ViewFriendsRequest, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ViewFriendsRequest, target_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ViewFriendsRequest, role_), + }; + ViewFriendsRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ViewFriendsRequest_descriptor_, + ViewFriendsRequest::default_instance_, + ViewFriendsRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ViewFriendsRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ViewFriendsRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ViewFriendsRequest)); + ViewFriendsResponse_descriptor_ = file->message_type(7); + static const int ViewFriendsResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ViewFriendsResponse, friends_), + }; + ViewFriendsResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ViewFriendsResponse_descriptor_, + ViewFriendsResponse::default_instance_, + ViewFriendsResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ViewFriendsResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ViewFriendsResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ViewFriendsResponse)); + UpdateFriendStateRequest_descriptor_ = file->message_type(8); + static const int UpdateFriendStateRequest_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateRequest, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateRequest, target_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateRequest, attribute_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateRequest, attributes_epoch_), + }; + UpdateFriendStateRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + UpdateFriendStateRequest_descriptor_, + UpdateFriendStateRequest::default_instance_, + UpdateFriendStateRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(UpdateFriendStateRequest)); + FriendNotification_descriptor_ = file->message_type(9); + static const int FriendNotification_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendNotification, target_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendNotification, game_account_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendNotification, peer_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendNotification, account_id_), + }; + FriendNotification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + FriendNotification_descriptor_, + FriendNotification::default_instance_, + FriendNotification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendNotification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendNotification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(FriendNotification)); + UpdateFriendStateNotification_descriptor_ = file->message_type(10); + static const int UpdateFriendStateNotification_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateNotification, changed_friend_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateNotification, game_account_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateNotification, peer_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateNotification, account_id_), + }; + UpdateFriendStateNotification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + UpdateFriendStateNotification_descriptor_, + UpdateFriendStateNotification::default_instance_, + UpdateFriendStateNotification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateNotification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateNotification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(UpdateFriendStateNotification)); + InvitationNotification_descriptor_ = file->message_type(11); + static const int InvitationNotification_offsets_[5] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationNotification, invitation_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationNotification, game_account_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationNotification, reason_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationNotification, peer_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationNotification, account_id_), + }; + InvitationNotification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + InvitationNotification_descriptor_, + InvitationNotification::default_instance_, + InvitationNotification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationNotification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationNotification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(InvitationNotification)); + FriendsService_descriptor_ = file->service(0); + FriendsListener_descriptor_ = file->service(1); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_friends_5fservice_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SubscribeRequest_descriptor_, &SubscribeRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SubscribeResponse_descriptor_, &SubscribeResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + UnsubscribeRequest_descriptor_, &UnsubscribeRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GenericFriendRequest_descriptor_, &GenericFriendRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GenericFriendResponse_descriptor_, &GenericFriendResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AssignRoleRequest_descriptor_, &AssignRoleRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ViewFriendsRequest_descriptor_, &ViewFriendsRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ViewFriendsResponse_descriptor_, &ViewFriendsResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + UpdateFriendStateRequest_descriptor_, &UpdateFriendStateRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + FriendNotification_descriptor_, &FriendNotification::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + UpdateFriendStateNotification_descriptor_, &UpdateFriendStateNotification::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + InvitationNotification_descriptor_, &InvitationNotification::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_friends_5fservice_2eproto() { + delete SubscribeRequest::default_instance_; + delete SubscribeRequest_reflection_; + delete SubscribeResponse::default_instance_; + delete SubscribeResponse_reflection_; + delete UnsubscribeRequest::default_instance_; + delete UnsubscribeRequest_reflection_; + delete GenericFriendRequest::default_instance_; + delete GenericFriendRequest_reflection_; + delete GenericFriendResponse::default_instance_; + delete GenericFriendResponse_reflection_; + delete AssignRoleRequest::default_instance_; + delete AssignRoleRequest_reflection_; + delete ViewFriendsRequest::default_instance_; + delete ViewFriendsRequest_reflection_; + delete ViewFriendsResponse::default_instance_; + delete ViewFriendsResponse_reflection_; + delete UpdateFriendStateRequest::default_instance_; + delete UpdateFriendStateRequest_reflection_; + delete FriendNotification::default_instance_; + delete FriendNotification_reflection_; + delete UpdateFriendStateNotification::default_instance_; + delete UpdateFriendStateNotification_reflection_; + delete InvitationNotification::default_instance_; + delete InvitationNotification_reflection_; +} + +void protobuf_AddDesc_friends_5fservice_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto(); + ::bgs::protocol::friends::v1::protobuf_AddDesc_friends_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_invitation_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_role_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\025friends_service.proto\022\027bgs.protocol.fr" + "iends.v1\032\025attribute_types.proto\032\022entity_" + "types.proto\032\023friends_types.proto\032\026invita" + "tion_types.proto\032\020role_types.proto\032\017rpc_" + "types.proto\"O\n\020SubscribeRequest\022(\n\010agent" + "_id\030\001 \001(\0132\026.bgs.protocol.EntityId\022\021\n\tobj" + "ect_id\030\002 \002(\004\"\250\002\n\021SubscribeResponse\022\023\n\013ma" + "x_friends\030\001 \001(\r\022 \n\030max_received_invitati" + "ons\030\002 \001(\r\022\034\n\024max_sent_invitations\030\003 \001(\r\022" + " \n\004role\030\004 \003(\0132\022.bgs.protocol.Role\0220\n\007fri" + "ends\030\005 \003(\0132\037.bgs.protocol.friends.v1.Fri" + "end\0222\n\020sent_invitations\030\006 \003(\0132\030.bgs.prot" + "ocol.Invitation\0226\n\024received_invitations\030" + "\007 \003(\0132\030.bgs.protocol.Invitation\"Q\n\022Unsub" + "scribeRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.pr" + "otocol.EntityId\022\021\n\tobject_id\030\002 \001(\004\"k\n\024Ge" + "nericFriendRequest\022(\n\010agent_id\030\001 \001(\0132\026.b" + "gs.protocol.EntityId\022)\n\ttarget_id\030\002 \002(\0132" + "\026.bgs.protocol.EntityId\"O\n\025GenericFriend" + "Response\0226\n\rtarget_friend\030\001 \001(\0132\037.bgs.pr" + "otocol.friends.v1.Friend\"v\n\021AssignRoleRe" + "quest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.protocol.E" + "ntityId\022)\n\ttarget_id\030\002 \002(\0132\026.bgs.protoco" + "l.EntityId\022\014\n\004role\030\003 \003(\005\"{\n\022ViewFriendsR" + "equest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.protocol." + "EntityId\022)\n\ttarget_id\030\002 \002(\0132\026.bgs.protoc" + "ol.EntityId\022\020\n\004role\030\003 \003(\rB\002\020\001\"G\n\023ViewFri" + "endsResponse\0220\n\007friends\030\001 \003(\0132\037.bgs.prot" + "ocol.friends.v1.Friend\"\265\001\n\030UpdateFriendS" + "tateRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.prot" + "ocol.EntityId\022)\n\ttarget_id\030\002 \002(\0132\026.bgs.p" + "rotocol.EntityId\022*\n\tattribute\030\003 \003(\0132\027.bg" + "s.protocol.Attribute\022\030\n\020attributes_epoch" + "\030\004 \001(\004\"\311\001\n\022FriendNotification\022/\n\006target\030" + "\001 \002(\0132\037.bgs.protocol.friends.v1.Friend\022/" + "\n\017game_account_id\030\002 \001(\0132\026.bgs.protocol.E" + "ntityId\022%\n\004peer\030\004 \001(\0132\027.bgs.protocol.Pro" + "cessId\022*\n\naccount_id\030\005 \001(\0132\026.bgs.protoco" + "l.EntityId\"\334\001\n\035UpdateFriendStateNotifica" + "tion\0227\n\016changed_friend\030\001 \002(\0132\037.bgs.proto" + "col.friends.v1.Friend\022/\n\017game_account_id" + "\030\002 \001(\0132\026.bgs.protocol.EntityId\022%\n\004peer\030\004" + " \001(\0132\027.bgs.protocol.ProcessId\022*\n\naccount" + "_id\030\005 \001(\0132\026.bgs.protocol.EntityId\"\335\001\n\026In" + "vitationNotification\022,\n\ninvitation\030\001 \002(\013" + "2\030.bgs.protocol.Invitation\022/\n\017game_accou" + "nt_id\030\002 \001(\0132\026.bgs.protocol.EntityId\022\021\n\006r" + "eason\030\003 \001(\r:\0010\022%\n\004peer\030\004 \001(\0132\027.bgs.proto" + "col.ProcessId\022*\n\naccount_id\030\005 \001(\0132\026.bgs." + "protocol.EntityId2\264\t\n\016FriendsService\022h\n\t" + "Subscribe\022).bgs.protocol.friends.v1.Subs" + "cribeRequest\032*.bgs.protocol.friends.v1.S" + "ubscribeResponse\"\004\200\265\030\001\022Q\n\016SendInvitation" + "\022#.bgs.protocol.SendInvitationRequest\032\024." + "bgs.protocol.NoData\"\004\200\265\030\002\022V\n\020AcceptInvit" + "ation\022&.bgs.protocol.GenericInvitationRe" + "quest\032\024.bgs.protocol.NoData\"\004\200\265\030\003\022Y\n\020Rev" + "okeInvitation\022&.bgs.protocol.GenericInvi" + "tationRequest\032\024.bgs.protocol.NoData\"\007\210\002\001" + "\200\265\030\004\022W\n\021DeclineInvitation\022&.bgs.protocol" + ".GenericInvitationRequest\032\024.bgs.protocol" + ".NoData\"\004\200\265\030\005\022V\n\020IgnoreInvitation\022&.bgs." + "protocol.GenericInvitationRequest\032\024.bgs." + "protocol.NoData\"\004\200\265\030\006\022T\n\nAssignRole\022*.bg" + "s.protocol.friends.v1.AssignRoleRequest\032" + "\024.bgs.protocol.NoData\"\004\200\265\030\007\022s\n\014RemoveFri" + "end\022-.bgs.protocol.friends.v1.GenericFri" + "endRequest\032..bgs.protocol.friends.v1.Gen" + "ericFriendResponse\"\004\200\265\030\010\022n\n\013ViewFriends\022" + "+.bgs.protocol.friends.v1.ViewFriendsReq" + "uest\032,.bgs.protocol.friends.v1.ViewFrien" + "dsResponse\"\004\200\265\030\t\022b\n\021UpdateFriendState\0221." + "bgs.protocol.friends.v1.UpdateFriendStat" + "eRequest\032\024.bgs.protocol.NoData\"\004\200\265\030\n\022V\n\013" + "Unsubscribe\022+.bgs.protocol.friends.v1.Un" + "subscribeRequest\032\024.bgs.protocol.NoData\"\004" + "\200\265\030\013\022a\n\024RevokeAllInvitations\022-.bgs.proto" + "col.friends.v1.GenericFriendRequest\032\024.bg" + "s.protocol.NoData\"\004\200\265\030\014\032\'\312>$bnet.protoco" + "l.friends.FriendsService2\247\006\n\017FriendsList" + "ener\022]\n\rOnFriendAdded\022+.bgs.protocol.fri" + "ends.v1.FriendNotification\032\031.bgs.protoco" + "l.NO_RESPONSE\"\004\200\265\030\001\022_\n\017OnFriendRemoved\022+" + ".bgs.protocol.friends.v1.FriendNotificat" + "ion\032\031.bgs.protocol.NO_RESPONSE\"\004\200\265\030\002\022m\n\031" + "OnReceivedInvitationAdded\022/.bgs.protocol" + ".friends.v1.InvitationNotification\032\031.bgs" + ".protocol.NO_RESPONSE\"\004\200\265\030\003\022o\n\033OnReceive" + "dInvitationRemoved\022/.bgs.protocol.friend" + "s.v1.InvitationNotification\032\031.bgs.protoc" + "ol.NO_RESPONSE\"\004\200\265\030\004\022l\n\025OnSentInvitation" + "Added\022/.bgs.protocol.friends.v1.Invitati" + "onNotification\032\031.bgs.protocol.NO_RESPONS" + "E\"\007\210\002\001\200\265\030\005\022n\n\027OnSentInvitationRemoved\022/." + "bgs.protocol.friends.v1.InvitationNotifi" + "cation\032\031.bgs.protocol.NO_RESPONSE\"\007\210\002\001\200\265" + "\030\006\022n\n\023OnUpdateFriendState\0226.bgs.protocol" + ".friends.v1.UpdateFriendStateNotificatio" + "n\032\031.bgs.protocol.NO_RESPONSE\"\004\200\265\030\007\032&\312>#b" + "net.protocol.friends.FriendsNotifyB7\n\030bn" + "et.protocol.friends.v1B\023FriendsServicePr" + "otoH\001\200\001\000\210\001\001", 4051); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "friends_service.proto", &protobuf_RegisterTypes); + SubscribeRequest::default_instance_ = new SubscribeRequest(); + SubscribeResponse::default_instance_ = new SubscribeResponse(); + UnsubscribeRequest::default_instance_ = new UnsubscribeRequest(); + GenericFriendRequest::default_instance_ = new GenericFriendRequest(); + GenericFriendResponse::default_instance_ = new GenericFriendResponse(); + AssignRoleRequest::default_instance_ = new AssignRoleRequest(); + ViewFriendsRequest::default_instance_ = new ViewFriendsRequest(); + ViewFriendsResponse::default_instance_ = new ViewFriendsResponse(); + UpdateFriendStateRequest::default_instance_ = new UpdateFriendStateRequest(); + FriendNotification::default_instance_ = new FriendNotification(); + UpdateFriendStateNotification::default_instance_ = new UpdateFriendStateNotification(); + InvitationNotification::default_instance_ = new InvitationNotification(); + SubscribeRequest::default_instance_->InitAsDefaultInstance(); + SubscribeResponse::default_instance_->InitAsDefaultInstance(); + UnsubscribeRequest::default_instance_->InitAsDefaultInstance(); + GenericFriendRequest::default_instance_->InitAsDefaultInstance(); + GenericFriendResponse::default_instance_->InitAsDefaultInstance(); + AssignRoleRequest::default_instance_->InitAsDefaultInstance(); + ViewFriendsRequest::default_instance_->InitAsDefaultInstance(); + ViewFriendsResponse::default_instance_->InitAsDefaultInstance(); + UpdateFriendStateRequest::default_instance_->InitAsDefaultInstance(); + FriendNotification::default_instance_->InitAsDefaultInstance(); + UpdateFriendStateNotification::default_instance_->InitAsDefaultInstance(); + InvitationNotification::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_friends_5fservice_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_friends_5fservice_2eproto { + StaticDescriptorInitializer_friends_5fservice_2eproto() { + protobuf_AddDesc_friends_5fservice_2eproto(); + } +} static_descriptor_initializer_friends_5fservice_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int SubscribeRequest::kAgentIdFieldNumber; +const int SubscribeRequest::kObjectIdFieldNumber; +#endif // !_MSC_VER + +SubscribeRequest::SubscribeRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.SubscribeRequest) +} + +void SubscribeRequest::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +SubscribeRequest::SubscribeRequest(const SubscribeRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.SubscribeRequest) +} + +void SubscribeRequest::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + object_id_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +SubscribeRequest::~SubscribeRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.SubscribeRequest) + SharedDtor(); +} + +void SubscribeRequest::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + } +} + +void SubscribeRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SubscribeRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SubscribeRequest_descriptor_; +} + +const SubscribeRequest& SubscribeRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto(); + return *default_instance_; +} + +SubscribeRequest* SubscribeRequest::default_instance_ = NULL; + +SubscribeRequest* SubscribeRequest::New() const { + return new SubscribeRequest; +} + +void SubscribeRequest::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + object_id_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool SubscribeRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.SubscribeRequest) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_object_id; + break; + } + + // required uint64 object_id = 2; + case 2: { + if (tag == 16) { + parse_object_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &object_id_))); + set_has_object_id(); + } 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:bgs.protocol.friends.v1.SubscribeRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.SubscribeRequest) + return false; +#undef DO_ +} + +void SubscribeRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.SubscribeRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // required uint64 object_id = 2; + if (has_object_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->object_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.SubscribeRequest) +} + +::google::protobuf::uint8* SubscribeRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.SubscribeRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // required uint64 object_id = 2; + if (has_object_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->object_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.SubscribeRequest) + return target; +} + +int SubscribeRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // required uint64 object_id = 2; + if (has_object_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->object_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void SubscribeRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const SubscribeRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void SubscribeRequest::MergeFrom(const SubscribeRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_object_id()) { + set_object_id(from.object_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void SubscribeRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SubscribeRequest::CopyFrom(const SubscribeRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SubscribeRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false; + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + return true; +} + +void SubscribeRequest::Swap(SubscribeRequest* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + std::swap(object_id_, other->object_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata SubscribeRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SubscribeRequest_descriptor_; + metadata.reflection = SubscribeRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int SubscribeResponse::kMaxFriendsFieldNumber; +const int SubscribeResponse::kMaxReceivedInvitationsFieldNumber; +const int SubscribeResponse::kMaxSentInvitationsFieldNumber; +const int SubscribeResponse::kRoleFieldNumber; +const int SubscribeResponse::kFriendsFieldNumber; +const int SubscribeResponse::kSentInvitationsFieldNumber; +const int SubscribeResponse::kReceivedInvitationsFieldNumber; +#endif // !_MSC_VER + +SubscribeResponse::SubscribeResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.SubscribeResponse) +} + +void SubscribeResponse::InitAsDefaultInstance() { +} + +SubscribeResponse::SubscribeResponse(const SubscribeResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.SubscribeResponse) +} + +void SubscribeResponse::SharedCtor() { + _cached_size_ = 0; + max_friends_ = 0u; + max_received_invitations_ = 0u; + max_sent_invitations_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +SubscribeResponse::~SubscribeResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.SubscribeResponse) + SharedDtor(); +} + +void SubscribeResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void SubscribeResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SubscribeResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SubscribeResponse_descriptor_; +} + +const SubscribeResponse& SubscribeResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto(); + return *default_instance_; +} + +SubscribeResponse* SubscribeResponse::default_instance_ = NULL; + +SubscribeResponse* SubscribeResponse::New() const { + return new SubscribeResponse; +} + +void SubscribeResponse::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(max_friends_, max_received_invitations_); + max_sent_invitations_ = 0u; + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + role_.Clear(); + friends_.Clear(); + sent_invitations_.Clear(); + received_invitations_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool SubscribeResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.SubscribeResponse) + 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 max_friends = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &max_friends_))); + set_has_max_friends(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_max_received_invitations; + break; + } + + // optional uint32 max_received_invitations = 2; + case 2: { + if (tag == 16) { + parse_max_received_invitations: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &max_received_invitations_))); + set_has_max_received_invitations(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_max_sent_invitations; + break; + } + + // optional uint32 max_sent_invitations = 3; + case 3: { + if (tag == 24) { + parse_max_sent_invitations: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &max_sent_invitations_))); + set_has_max_sent_invitations(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_role; + break; + } + + // repeated .bgs.protocol.Role role = 4; + case 4: { + if (tag == 34) { + parse_role: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_role())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_role; + if (input->ExpectTag(42)) goto parse_friends; + break; + } + + // repeated .bgs.protocol.friends.v1.Friend friends = 5; + case 5: { + if (tag == 42) { + parse_friends: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_friends())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_friends; + if (input->ExpectTag(50)) goto parse_sent_invitations; + break; + } + + // repeated .bgs.protocol.Invitation sent_invitations = 6; + case 6: { + if (tag == 50) { + parse_sent_invitations: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_sent_invitations())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_sent_invitations; + if (input->ExpectTag(58)) goto parse_received_invitations; + break; + } + + // repeated .bgs.protocol.Invitation received_invitations = 7; + case 7: { + if (tag == 58) { + parse_received_invitations: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_received_invitations())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(58)) goto parse_received_invitations; + 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:bgs.protocol.friends.v1.SubscribeResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.SubscribeResponse) + return false; +#undef DO_ +} + +void SubscribeResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.SubscribeResponse) + // optional uint32 max_friends = 1; + if (has_max_friends()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->max_friends(), output); + } + + // optional uint32 max_received_invitations = 2; + if (has_max_received_invitations()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->max_received_invitations(), output); + } + + // optional uint32 max_sent_invitations = 3; + if (has_max_sent_invitations()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->max_sent_invitations(), output); + } + + // repeated .bgs.protocol.Role role = 4; + for (int i = 0; i < this->role_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->role(i), output); + } + + // repeated .bgs.protocol.friends.v1.Friend friends = 5; + for (int i = 0; i < this->friends_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, this->friends(i), output); + } + + // repeated .bgs.protocol.Invitation sent_invitations = 6; + for (int i = 0; i < this->sent_invitations_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, this->sent_invitations(i), output); + } + + // repeated .bgs.protocol.Invitation received_invitations = 7; + for (int i = 0; i < this->received_invitations_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 7, this->received_invitations(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.SubscribeResponse) +} + +::google::protobuf::uint8* SubscribeResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.SubscribeResponse) + // optional uint32 max_friends = 1; + if (has_max_friends()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->max_friends(), target); + } + + // optional uint32 max_received_invitations = 2; + if (has_max_received_invitations()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->max_received_invitations(), target); + } + + // optional uint32 max_sent_invitations = 3; + if (has_max_sent_invitations()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->max_sent_invitations(), target); + } + + // repeated .bgs.protocol.Role role = 4; + for (int i = 0; i < this->role_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->role(i), target); + } + + // repeated .bgs.protocol.friends.v1.Friend friends = 5; + for (int i = 0; i < this->friends_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 5, this->friends(i), target); + } + + // repeated .bgs.protocol.Invitation sent_invitations = 6; + for (int i = 0; i < this->sent_invitations_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 6, this->sent_invitations(i), target); + } + + // repeated .bgs.protocol.Invitation received_invitations = 7; + for (int i = 0; i < this->received_invitations_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 7, this->received_invitations(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.SubscribeResponse) + return target; +} + +int SubscribeResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional uint32 max_friends = 1; + if (has_max_friends()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->max_friends()); + } + + // optional uint32 max_received_invitations = 2; + if (has_max_received_invitations()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->max_received_invitations()); + } + + // optional uint32 max_sent_invitations = 3; + if (has_max_sent_invitations()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->max_sent_invitations()); + } + + } + // repeated .bgs.protocol.Role role = 4; + total_size += 1 * this->role_size(); + for (int i = 0; i < this->role_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->role(i)); + } + + // repeated .bgs.protocol.friends.v1.Friend friends = 5; + total_size += 1 * this->friends_size(); + for (int i = 0; i < this->friends_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->friends(i)); + } + + // repeated .bgs.protocol.Invitation sent_invitations = 6; + total_size += 1 * this->sent_invitations_size(); + for (int i = 0; i < this->sent_invitations_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->sent_invitations(i)); + } + + // repeated .bgs.protocol.Invitation received_invitations = 7; + total_size += 1 * this->received_invitations_size(); + for (int i = 0; i < this->received_invitations_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->received_invitations(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 SubscribeResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const SubscribeResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void SubscribeResponse::MergeFrom(const SubscribeResponse& from) { + GOOGLE_CHECK_NE(&from, this); + role_.MergeFrom(from.role_); + friends_.MergeFrom(from.friends_); + sent_invitations_.MergeFrom(from.sent_invitations_); + received_invitations_.MergeFrom(from.received_invitations_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_max_friends()) { + set_max_friends(from.max_friends()); + } + if (from.has_max_received_invitations()) { + set_max_received_invitations(from.max_received_invitations()); + } + if (from.has_max_sent_invitations()) { + set_max_sent_invitations(from.max_sent_invitations()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void SubscribeResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SubscribeResponse::CopyFrom(const SubscribeResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SubscribeResponse::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->role())) return false; + if (!::google::protobuf::internal::AllAreInitialized(this->friends())) return false; + if (!::google::protobuf::internal::AllAreInitialized(this->sent_invitations())) return false; + if (!::google::protobuf::internal::AllAreInitialized(this->received_invitations())) return false; + return true; +} + +void SubscribeResponse::Swap(SubscribeResponse* other) { + if (other != this) { + std::swap(max_friends_, other->max_friends_); + std::swap(max_received_invitations_, other->max_received_invitations_); + std::swap(max_sent_invitations_, other->max_sent_invitations_); + role_.Swap(&other->role_); + friends_.Swap(&other->friends_); + sent_invitations_.Swap(&other->sent_invitations_); + received_invitations_.Swap(&other->received_invitations_); + 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 SubscribeResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SubscribeResponse_descriptor_; + metadata.reflection = SubscribeResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int UnsubscribeRequest::kAgentIdFieldNumber; +const int UnsubscribeRequest::kObjectIdFieldNumber; +#endif // !_MSC_VER + +UnsubscribeRequest::UnsubscribeRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.UnsubscribeRequest) +} + +void UnsubscribeRequest::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +UnsubscribeRequest::UnsubscribeRequest(const UnsubscribeRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.UnsubscribeRequest) +} + +void UnsubscribeRequest::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + object_id_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +UnsubscribeRequest::~UnsubscribeRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.UnsubscribeRequest) + SharedDtor(); +} + +void UnsubscribeRequest::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + } +} + +void UnsubscribeRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* UnsubscribeRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return UnsubscribeRequest_descriptor_; +} + +const UnsubscribeRequest& UnsubscribeRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto(); + return *default_instance_; +} + +UnsubscribeRequest* UnsubscribeRequest::default_instance_ = NULL; + +UnsubscribeRequest* UnsubscribeRequest::New() const { + return new UnsubscribeRequest; +} + +void UnsubscribeRequest::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + object_id_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool UnsubscribeRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.UnsubscribeRequest) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_object_id; + break; + } + + // optional uint64 object_id = 2; + case 2: { + if (tag == 16) { + parse_object_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &object_id_))); + set_has_object_id(); + } 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:bgs.protocol.friends.v1.UnsubscribeRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.UnsubscribeRequest) + return false; +#undef DO_ +} + +void UnsubscribeRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.UnsubscribeRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // optional uint64 object_id = 2; + if (has_object_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->object_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.UnsubscribeRequest) +} + +::google::protobuf::uint8* UnsubscribeRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.UnsubscribeRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // optional uint64 object_id = 2; + if (has_object_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->object_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.UnsubscribeRequest) + return target; +} + +int UnsubscribeRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // optional uint64 object_id = 2; + if (has_object_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->object_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void UnsubscribeRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const UnsubscribeRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void UnsubscribeRequest::MergeFrom(const UnsubscribeRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_object_id()) { + set_object_id(from.object_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void UnsubscribeRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void UnsubscribeRequest::CopyFrom(const UnsubscribeRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool UnsubscribeRequest::IsInitialized() const { + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + return true; +} + +void UnsubscribeRequest::Swap(UnsubscribeRequest* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + std::swap(object_id_, other->object_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata UnsubscribeRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = UnsubscribeRequest_descriptor_; + metadata.reflection = UnsubscribeRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GenericFriendRequest::kAgentIdFieldNumber; +const int GenericFriendRequest::kTargetIdFieldNumber; +#endif // !_MSC_VER + +GenericFriendRequest::GenericFriendRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.GenericFriendRequest) +} + +void GenericFriendRequest::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +GenericFriendRequest::GenericFriendRequest(const GenericFriendRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.GenericFriendRequest) +} + +void GenericFriendRequest::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + target_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GenericFriendRequest::~GenericFriendRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.GenericFriendRequest) + SharedDtor(); +} + +void GenericFriendRequest::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + delete target_id_; + } +} + +void GenericFriendRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GenericFriendRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GenericFriendRequest_descriptor_; +} + +const GenericFriendRequest& GenericFriendRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto(); + return *default_instance_; +} + +GenericFriendRequest* GenericFriendRequest::default_instance_ = NULL; + +GenericFriendRequest* GenericFriendRequest::New() const { + return new GenericFriendRequest; +} + +void GenericFriendRequest::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_target_id()) { + if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GenericFriendRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.GenericFriendRequest) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_target_id; + break; + } + + // required .bgs.protocol.EntityId target_id = 2; + case 2: { + if (tag == 18) { + parse_target_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_target_id())); + } 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:bgs.protocol.friends.v1.GenericFriendRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.GenericFriendRequest) + return false; +#undef DO_ +} + +void GenericFriendRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.GenericFriendRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // required .bgs.protocol.EntityId target_id = 2; + if (has_target_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->target_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.GenericFriendRequest) +} + +::google::protobuf::uint8* GenericFriendRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.GenericFriendRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // required .bgs.protocol.EntityId target_id = 2; + if (has_target_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->target_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.GenericFriendRequest) + return target; +} + +int GenericFriendRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // required .bgs.protocol.EntityId target_id = 2; + if (has_target_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->target_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void GenericFriendRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GenericFriendRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GenericFriendRequest::MergeFrom(const GenericFriendRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_target_id()) { + mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GenericFriendRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GenericFriendRequest::CopyFrom(const GenericFriendRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GenericFriendRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false; + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + if (has_target_id()) { + if (!this->target_id().IsInitialized()) return false; + } + return true; +} + +void GenericFriendRequest::Swap(GenericFriendRequest* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + std::swap(target_id_, other->target_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata GenericFriendRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GenericFriendRequest_descriptor_; + metadata.reflection = GenericFriendRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GenericFriendResponse::kTargetFriendFieldNumber; +#endif // !_MSC_VER + +GenericFriendResponse::GenericFriendResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.GenericFriendResponse) +} + +void GenericFriendResponse::InitAsDefaultInstance() { + target_friend_ = const_cast< ::bgs::protocol::friends::v1::Friend*>(&::bgs::protocol::friends::v1::Friend::default_instance()); +} + +GenericFriendResponse::GenericFriendResponse(const GenericFriendResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.GenericFriendResponse) +} + +void GenericFriendResponse::SharedCtor() { + _cached_size_ = 0; + target_friend_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GenericFriendResponse::~GenericFriendResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.GenericFriendResponse) + SharedDtor(); +} + +void GenericFriendResponse::SharedDtor() { + if (this != default_instance_) { + delete target_friend_; + } +} + +void GenericFriendResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GenericFriendResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GenericFriendResponse_descriptor_; +} + +const GenericFriendResponse& GenericFriendResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto(); + return *default_instance_; +} + +GenericFriendResponse* GenericFriendResponse::default_instance_ = NULL; + +GenericFriendResponse* GenericFriendResponse::New() const { + return new GenericFriendResponse; +} + +void GenericFriendResponse::Clear() { + if (has_target_friend()) { + if (target_friend_ != NULL) target_friend_->::bgs::protocol::friends::v1::Friend::Clear(); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GenericFriendResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.GenericFriendResponse) + 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 .bgs.protocol.friends.v1.Friend target_friend = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_target_friend())); + } 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:bgs.protocol.friends.v1.GenericFriendResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.GenericFriendResponse) + return false; +#undef DO_ +} + +void GenericFriendResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.GenericFriendResponse) + // optional .bgs.protocol.friends.v1.Friend target_friend = 1; + if (has_target_friend()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->target_friend(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.GenericFriendResponse) +} + +::google::protobuf::uint8* GenericFriendResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.GenericFriendResponse) + // optional .bgs.protocol.friends.v1.Friend target_friend = 1; + if (has_target_friend()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->target_friend(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.GenericFriendResponse) + return target; +} + +int GenericFriendResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.friends.v1.Friend target_friend = 1; + if (has_target_friend()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->target_friend()); + } + + } + 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 GenericFriendResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GenericFriendResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GenericFriendResponse::MergeFrom(const GenericFriendResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_target_friend()) { + mutable_target_friend()->::bgs::protocol::friends::v1::Friend::MergeFrom(from.target_friend()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GenericFriendResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GenericFriendResponse::CopyFrom(const GenericFriendResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GenericFriendResponse::IsInitialized() const { + + if (has_target_friend()) { + if (!this->target_friend().IsInitialized()) return false; + } + return true; +} + +void GenericFriendResponse::Swap(GenericFriendResponse* other) { + if (other != this) { + std::swap(target_friend_, other->target_friend_); + 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 GenericFriendResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GenericFriendResponse_descriptor_; + metadata.reflection = GenericFriendResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AssignRoleRequest::kAgentIdFieldNumber; +const int AssignRoleRequest::kTargetIdFieldNumber; +const int AssignRoleRequest::kRoleFieldNumber; +#endif // !_MSC_VER + +AssignRoleRequest::AssignRoleRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.AssignRoleRequest) +} + +void AssignRoleRequest::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +AssignRoleRequest::AssignRoleRequest(const AssignRoleRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.AssignRoleRequest) +} + +void AssignRoleRequest::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + target_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AssignRoleRequest::~AssignRoleRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.AssignRoleRequest) + SharedDtor(); +} + +void AssignRoleRequest::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + delete target_id_; + } +} + +void AssignRoleRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AssignRoleRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AssignRoleRequest_descriptor_; +} + +const AssignRoleRequest& AssignRoleRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto(); + return *default_instance_; +} + +AssignRoleRequest* AssignRoleRequest::default_instance_ = NULL; + +AssignRoleRequest* AssignRoleRequest::New() const { + return new AssignRoleRequest; +} + +void AssignRoleRequest::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_target_id()) { + if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear(); + } + } + role_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AssignRoleRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.AssignRoleRequest) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_target_id; + break; + } + + // required .bgs.protocol.EntityId target_id = 2; + case 2: { + if (tag == 18) { + parse_target_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_target_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_role; + break; + } + + // repeated int32 role = 3; + case 3: { + if (tag == 24) { + parse_role: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + 1, 24, input, this->mutable_role()))); + } else if (tag == 26) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, this->mutable_role()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_role; + 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:bgs.protocol.friends.v1.AssignRoleRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.AssignRoleRequest) + return false; +#undef DO_ +} + +void AssignRoleRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.AssignRoleRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // required .bgs.protocol.EntityId target_id = 2; + if (has_target_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->target_id(), output); + } + + // repeated int32 role = 3; + for (int i = 0; i < this->role_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteInt32( + 3, this->role(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.AssignRoleRequest) +} + +::google::protobuf::uint8* AssignRoleRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.AssignRoleRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // required .bgs.protocol.EntityId target_id = 2; + if (has_target_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->target_id(), target); + } + + // repeated int32 role = 3; + for (int i = 0; i < this->role_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32ToArray(3, this->role(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.AssignRoleRequest) + return target; +} + +int AssignRoleRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // required .bgs.protocol.EntityId target_id = 2; + if (has_target_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->target_id()); + } + + } + // repeated int32 role = 3; + { + int data_size = 0; + for (int i = 0; i < this->role_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + Int32Size(this->role(i)); + } + total_size += 1 * this->role_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 AssignRoleRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AssignRoleRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AssignRoleRequest::MergeFrom(const AssignRoleRequest& from) { + GOOGLE_CHECK_NE(&from, this); + role_.MergeFrom(from.role_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_target_id()) { + mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AssignRoleRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AssignRoleRequest::CopyFrom(const AssignRoleRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AssignRoleRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false; + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + if (has_target_id()) { + if (!this->target_id().IsInitialized()) return false; + } + return true; +} + +void AssignRoleRequest::Swap(AssignRoleRequest* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + std::swap(target_id_, other->target_id_); + role_.Swap(&other->role_); + 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 AssignRoleRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AssignRoleRequest_descriptor_; + metadata.reflection = AssignRoleRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ViewFriendsRequest::kAgentIdFieldNumber; +const int ViewFriendsRequest::kTargetIdFieldNumber; +const int ViewFriendsRequest::kRoleFieldNumber; +#endif // !_MSC_VER + +ViewFriendsRequest::ViewFriendsRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.ViewFriendsRequest) +} + +void ViewFriendsRequest::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +ViewFriendsRequest::ViewFriendsRequest(const ViewFriendsRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.ViewFriendsRequest) +} + +void ViewFriendsRequest::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + target_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ViewFriendsRequest::~ViewFriendsRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.ViewFriendsRequest) + SharedDtor(); +} + +void ViewFriendsRequest::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + delete target_id_; + } +} + +void ViewFriendsRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ViewFriendsRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ViewFriendsRequest_descriptor_; +} + +const ViewFriendsRequest& ViewFriendsRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto(); + return *default_instance_; +} + +ViewFriendsRequest* ViewFriendsRequest::default_instance_ = NULL; + +ViewFriendsRequest* ViewFriendsRequest::New() const { + return new ViewFriendsRequest; +} + +void ViewFriendsRequest::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_target_id()) { + if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear(); + } + } + role_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ViewFriendsRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.ViewFriendsRequest) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_target_id; + break; + } + + // required .bgs.protocol.EntityId target_id = 2; + case 2: { + if (tag == 18) { + parse_target_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_target_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_role; + break; + } + + // repeated uint32 role = 3 [packed = true]; + case 3: { + if (tag == 26) { + parse_role: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_role()))); + } else if (tag == 24) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 26, input, this->mutable_role()))); + } 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:bgs.protocol.friends.v1.ViewFriendsRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.ViewFriendsRequest) + return false; +#undef DO_ +} + +void ViewFriendsRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.ViewFriendsRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // required .bgs.protocol.EntityId target_id = 2; + if (has_target_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->target_id(), output); + } + + // repeated uint32 role = 3 [packed = true]; + if (this->role_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(3, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_role_cached_byte_size_); + } + for (int i = 0; i < this->role_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag( + this->role(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.ViewFriendsRequest) +} + +::google::protobuf::uint8* ViewFriendsRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.ViewFriendsRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // required .bgs.protocol.EntityId target_id = 2; + if (has_target_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->target_id(), target); + } + + // repeated uint32 role = 3 [packed = true]; + if (this->role_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 3, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _role_cached_byte_size_, target); + } + for (int i = 0; i < this->role_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32NoTagToArray(this->role(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.ViewFriendsRequest) + return target; +} + +int ViewFriendsRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // required .bgs.protocol.EntityId target_id = 2; + if (has_target_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->target_id()); + } + + } + // repeated uint32 role = 3 [packed = true]; + { + int data_size = 0; + for (int i = 0; i < this->role_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->role(i)); + } + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _role_cached_byte_size_ = data_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_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 ViewFriendsRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ViewFriendsRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ViewFriendsRequest::MergeFrom(const ViewFriendsRequest& from) { + GOOGLE_CHECK_NE(&from, this); + role_.MergeFrom(from.role_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_target_id()) { + mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ViewFriendsRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ViewFriendsRequest::CopyFrom(const ViewFriendsRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ViewFriendsRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false; + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + if (has_target_id()) { + if (!this->target_id().IsInitialized()) return false; + } + return true; +} + +void ViewFriendsRequest::Swap(ViewFriendsRequest* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + std::swap(target_id_, other->target_id_); + role_.Swap(&other->role_); + 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 ViewFriendsRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ViewFriendsRequest_descriptor_; + metadata.reflection = ViewFriendsRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ViewFriendsResponse::kFriendsFieldNumber; +#endif // !_MSC_VER + +ViewFriendsResponse::ViewFriendsResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.ViewFriendsResponse) +} + +void ViewFriendsResponse::InitAsDefaultInstance() { +} + +ViewFriendsResponse::ViewFriendsResponse(const ViewFriendsResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.ViewFriendsResponse) +} + +void ViewFriendsResponse::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ViewFriendsResponse::~ViewFriendsResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.ViewFriendsResponse) + SharedDtor(); +} + +void ViewFriendsResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void ViewFriendsResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ViewFriendsResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ViewFriendsResponse_descriptor_; +} + +const ViewFriendsResponse& ViewFriendsResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto(); + return *default_instance_; +} + +ViewFriendsResponse* ViewFriendsResponse::default_instance_ = NULL; + +ViewFriendsResponse* ViewFriendsResponse::New() const { + return new ViewFriendsResponse; +} + +void ViewFriendsResponse::Clear() { + friends_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ViewFriendsResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.ViewFriendsResponse) + 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 .bgs.protocol.friends.v1.Friend friends = 1; + case 1: { + if (tag == 10) { + parse_friends: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_friends())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_friends; + 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:bgs.protocol.friends.v1.ViewFriendsResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.ViewFriendsResponse) + return false; +#undef DO_ +} + +void ViewFriendsResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.ViewFriendsResponse) + // repeated .bgs.protocol.friends.v1.Friend friends = 1; + for (int i = 0; i < this->friends_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->friends(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.ViewFriendsResponse) +} + +::google::protobuf::uint8* ViewFriendsResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.ViewFriendsResponse) + // repeated .bgs.protocol.friends.v1.Friend friends = 1; + for (int i = 0; i < this->friends_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->friends(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.ViewFriendsResponse) + return target; +} + +int ViewFriendsResponse::ByteSize() const { + int total_size = 0; + + // repeated .bgs.protocol.friends.v1.Friend friends = 1; + total_size += 1 * this->friends_size(); + for (int i = 0; i < this->friends_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->friends(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 ViewFriendsResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ViewFriendsResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ViewFriendsResponse::MergeFrom(const ViewFriendsResponse& from) { + GOOGLE_CHECK_NE(&from, this); + friends_.MergeFrom(from.friends_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ViewFriendsResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ViewFriendsResponse::CopyFrom(const ViewFriendsResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ViewFriendsResponse::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->friends())) return false; + return true; +} + +void ViewFriendsResponse::Swap(ViewFriendsResponse* other) { + if (other != this) { + friends_.Swap(&other->friends_); + 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 ViewFriendsResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ViewFriendsResponse_descriptor_; + metadata.reflection = ViewFriendsResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int UpdateFriendStateRequest::kAgentIdFieldNumber; +const int UpdateFriendStateRequest::kTargetIdFieldNumber; +const int UpdateFriendStateRequest::kAttributeFieldNumber; +const int UpdateFriendStateRequest::kAttributesEpochFieldNumber; +#endif // !_MSC_VER + +UpdateFriendStateRequest::UpdateFriendStateRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.UpdateFriendStateRequest) +} + +void UpdateFriendStateRequest::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +UpdateFriendStateRequest::UpdateFriendStateRequest(const UpdateFriendStateRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.UpdateFriendStateRequest) +} + +void UpdateFriendStateRequest::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + target_id_ = NULL; + attributes_epoch_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +UpdateFriendStateRequest::~UpdateFriendStateRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.UpdateFriendStateRequest) + SharedDtor(); +} + +void UpdateFriendStateRequest::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + delete target_id_; + } +} + +void UpdateFriendStateRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* UpdateFriendStateRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return UpdateFriendStateRequest_descriptor_; +} + +const UpdateFriendStateRequest& UpdateFriendStateRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto(); + return *default_instance_; +} + +UpdateFriendStateRequest* UpdateFriendStateRequest::default_instance_ = NULL; + +UpdateFriendStateRequest* UpdateFriendStateRequest::New() const { + return new UpdateFriendStateRequest; +} + +void UpdateFriendStateRequest::Clear() { + if (_has_bits_[0 / 32] & 11) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_target_id()) { + if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear(); + } + attributes_epoch_ = GOOGLE_ULONGLONG(0); + } + attribute_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool UpdateFriendStateRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.UpdateFriendStateRequest) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_target_id; + break; + } + + // required .bgs.protocol.EntityId target_id = 2; + case 2: { + if (tag == 18) { + parse_target_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_target_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_attribute; + break; + } + + // repeated .bgs.protocol.Attribute attribute = 3; + case 3: { + if (tag == 26) { + parse_attribute: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_attribute())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_attribute; + if (input->ExpectTag(32)) goto parse_attributes_epoch; + break; + } + + // optional uint64 attributes_epoch = 4; + case 4: { + if (tag == 32) { + parse_attributes_epoch: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &attributes_epoch_))); + set_has_attributes_epoch(); + } 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:bgs.protocol.friends.v1.UpdateFriendStateRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.UpdateFriendStateRequest) + return false; +#undef DO_ +} + +void UpdateFriendStateRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.UpdateFriendStateRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // required .bgs.protocol.EntityId target_id = 2; + if (has_target_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->target_id(), output); + } + + // repeated .bgs.protocol.Attribute attribute = 3; + for (int i = 0; i < this->attribute_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->attribute(i), output); + } + + // optional uint64 attributes_epoch = 4; + if (has_attributes_epoch()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->attributes_epoch(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.UpdateFriendStateRequest) +} + +::google::protobuf::uint8* UpdateFriendStateRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.UpdateFriendStateRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // required .bgs.protocol.EntityId target_id = 2; + if (has_target_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->target_id(), target); + } + + // repeated .bgs.protocol.Attribute attribute = 3; + for (int i = 0; i < this->attribute_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->attribute(i), target); + } + + // optional uint64 attributes_epoch = 4; + if (has_attributes_epoch()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->attributes_epoch(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.UpdateFriendStateRequest) + return target; +} + +int UpdateFriendStateRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // required .bgs.protocol.EntityId target_id = 2; + if (has_target_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->target_id()); + } + + // optional uint64 attributes_epoch = 4; + if (has_attributes_epoch()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->attributes_epoch()); + } + + } + // repeated .bgs.protocol.Attribute attribute = 3; + total_size += 1 * this->attribute_size(); + for (int i = 0; i < this->attribute_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->attribute(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 UpdateFriendStateRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const UpdateFriendStateRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void UpdateFriendStateRequest::MergeFrom(const UpdateFriendStateRequest& from) { + GOOGLE_CHECK_NE(&from, this); + attribute_.MergeFrom(from.attribute_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_target_id()) { + mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id()); + } + if (from.has_attributes_epoch()) { + set_attributes_epoch(from.attributes_epoch()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void UpdateFriendStateRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void UpdateFriendStateRequest::CopyFrom(const UpdateFriendStateRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool UpdateFriendStateRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false; + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + if (has_target_id()) { + if (!this->target_id().IsInitialized()) return false; + } + if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false; + return true; +} + +void UpdateFriendStateRequest::Swap(UpdateFriendStateRequest* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + std::swap(target_id_, other->target_id_); + attribute_.Swap(&other->attribute_); + std::swap(attributes_epoch_, other->attributes_epoch_); + 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 UpdateFriendStateRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = UpdateFriendStateRequest_descriptor_; + metadata.reflection = UpdateFriendStateRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int FriendNotification::kTargetFieldNumber; +const int FriendNotification::kGameAccountIdFieldNumber; +const int FriendNotification::kPeerFieldNumber; +const int FriendNotification::kAccountIdFieldNumber; +#endif // !_MSC_VER + +FriendNotification::FriendNotification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.FriendNotification) +} + +void FriendNotification::InitAsDefaultInstance() { + target_ = const_cast< ::bgs::protocol::friends::v1::Friend*>(&::bgs::protocol::friends::v1::Friend::default_instance()); + game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + peer_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance()); + account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +FriendNotification::FriendNotification(const FriendNotification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.FriendNotification) +} + +void FriendNotification::SharedCtor() { + _cached_size_ = 0; + target_ = NULL; + game_account_id_ = NULL; + peer_ = NULL; + account_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +FriendNotification::~FriendNotification() { + // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.FriendNotification) + SharedDtor(); +} + +void FriendNotification::SharedDtor() { + if (this != default_instance_) { + delete target_; + delete game_account_id_; + delete peer_; + delete account_id_; + } +} + +void FriendNotification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* FriendNotification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return FriendNotification_descriptor_; +} + +const FriendNotification& FriendNotification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto(); + return *default_instance_; +} + +FriendNotification* FriendNotification::default_instance_ = NULL; + +FriendNotification* FriendNotification::New() const { + return new FriendNotification; +} + +void FriendNotification::Clear() { + if (_has_bits_[0 / 32] & 15) { + if (has_target()) { + if (target_ != NULL) target_->::bgs::protocol::friends::v1::Friend::Clear(); + } + if (has_game_account_id()) { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_peer()) { + if (peer_ != NULL) peer_->::bgs::protocol::ProcessId::Clear(); + } + if (has_account_id()) { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool FriendNotification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.FriendNotification) + 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)) { + // required .bgs.protocol.friends.v1.Friend target = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_target())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_game_account_id; + break; + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + case 2: { + if (tag == 18) { + parse_game_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_peer; + break; + } + + // optional .bgs.protocol.ProcessId peer = 4; + case 4: { + if (tag == 34) { + parse_peer: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_peer())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_account_id; + break; + } + + // optional .bgs.protocol.EntityId account_id = 5; + case 5: { + if (tag == 42) { + parse_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account_id())); + } 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:bgs.protocol.friends.v1.FriendNotification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.FriendNotification) + return false; +#undef DO_ +} + +void FriendNotification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.FriendNotification) + // required .bgs.protocol.friends.v1.Friend target = 1; + if (has_target()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->target(), output); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->game_account_id(), output); + } + + // optional .bgs.protocol.ProcessId peer = 4; + if (has_peer()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->peer(), output); + } + + // optional .bgs.protocol.EntityId account_id = 5; + if (has_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, this->account_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.FriendNotification) +} + +::google::protobuf::uint8* FriendNotification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.FriendNotification) + // required .bgs.protocol.friends.v1.Friend target = 1; + if (has_target()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->target(), target); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->game_account_id(), target); + } + + // optional .bgs.protocol.ProcessId peer = 4; + if (has_peer()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->peer(), target); + } + + // optional .bgs.protocol.EntityId account_id = 5; + if (has_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 5, this->account_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.FriendNotification) + return target; +} + +int FriendNotification::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.friends.v1.Friend target = 1; + if (has_target()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->target()); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account_id()); + } + + // optional .bgs.protocol.ProcessId peer = 4; + if (has_peer()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->peer()); + } + + // optional .bgs.protocol.EntityId account_id = 5; + if (has_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void FriendNotification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const FriendNotification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void FriendNotification::MergeFrom(const FriendNotification& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_target()) { + mutable_target()->::bgs::protocol::friends::v1::Friend::MergeFrom(from.target()); + } + if (from.has_game_account_id()) { + mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id()); + } + if (from.has_peer()) { + mutable_peer()->::bgs::protocol::ProcessId::MergeFrom(from.peer()); + } + if (from.has_account_id()) { + mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void FriendNotification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FriendNotification::CopyFrom(const FriendNotification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FriendNotification::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_target()) { + if (!this->target().IsInitialized()) return false; + } + if (has_game_account_id()) { + if (!this->game_account_id().IsInitialized()) return false; + } + if (has_peer()) { + if (!this->peer().IsInitialized()) return false; + } + if (has_account_id()) { + if (!this->account_id().IsInitialized()) return false; + } + return true; +} + +void FriendNotification::Swap(FriendNotification* other) { + if (other != this) { + std::swap(target_, other->target_); + std::swap(game_account_id_, other->game_account_id_); + std::swap(peer_, other->peer_); + std::swap(account_id_, other->account_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata FriendNotification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = FriendNotification_descriptor_; + metadata.reflection = FriendNotification_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int UpdateFriendStateNotification::kChangedFriendFieldNumber; +const int UpdateFriendStateNotification::kGameAccountIdFieldNumber; +const int UpdateFriendStateNotification::kPeerFieldNumber; +const int UpdateFriendStateNotification::kAccountIdFieldNumber; +#endif // !_MSC_VER + +UpdateFriendStateNotification::UpdateFriendStateNotification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.UpdateFriendStateNotification) +} + +void UpdateFriendStateNotification::InitAsDefaultInstance() { + changed_friend_ = const_cast< ::bgs::protocol::friends::v1::Friend*>(&::bgs::protocol::friends::v1::Friend::default_instance()); + game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + peer_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance()); + account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +UpdateFriendStateNotification::UpdateFriendStateNotification(const UpdateFriendStateNotification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.UpdateFriendStateNotification) +} + +void UpdateFriendStateNotification::SharedCtor() { + _cached_size_ = 0; + changed_friend_ = NULL; + game_account_id_ = NULL; + peer_ = NULL; + account_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +UpdateFriendStateNotification::~UpdateFriendStateNotification() { + // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.UpdateFriendStateNotification) + SharedDtor(); +} + +void UpdateFriendStateNotification::SharedDtor() { + if (this != default_instance_) { + delete changed_friend_; + delete game_account_id_; + delete peer_; + delete account_id_; + } +} + +void UpdateFriendStateNotification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* UpdateFriendStateNotification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return UpdateFriendStateNotification_descriptor_; +} + +const UpdateFriendStateNotification& UpdateFriendStateNotification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto(); + return *default_instance_; +} + +UpdateFriendStateNotification* UpdateFriendStateNotification::default_instance_ = NULL; + +UpdateFriendStateNotification* UpdateFriendStateNotification::New() const { + return new UpdateFriendStateNotification; +} + +void UpdateFriendStateNotification::Clear() { + if (_has_bits_[0 / 32] & 15) { + if (has_changed_friend()) { + if (changed_friend_ != NULL) changed_friend_->::bgs::protocol::friends::v1::Friend::Clear(); + } + if (has_game_account_id()) { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_peer()) { + if (peer_ != NULL) peer_->::bgs::protocol::ProcessId::Clear(); + } + if (has_account_id()) { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool UpdateFriendStateNotification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.UpdateFriendStateNotification) + 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)) { + // required .bgs.protocol.friends.v1.Friend changed_friend = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_changed_friend())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_game_account_id; + break; + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + case 2: { + if (tag == 18) { + parse_game_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_peer; + break; + } + + // optional .bgs.protocol.ProcessId peer = 4; + case 4: { + if (tag == 34) { + parse_peer: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_peer())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_account_id; + break; + } + + // optional .bgs.protocol.EntityId account_id = 5; + case 5: { + if (tag == 42) { + parse_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account_id())); + } 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:bgs.protocol.friends.v1.UpdateFriendStateNotification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.UpdateFriendStateNotification) + return false; +#undef DO_ +} + +void UpdateFriendStateNotification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.UpdateFriendStateNotification) + // required .bgs.protocol.friends.v1.Friend changed_friend = 1; + if (has_changed_friend()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->changed_friend(), output); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->game_account_id(), output); + } + + // optional .bgs.protocol.ProcessId peer = 4; + if (has_peer()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->peer(), output); + } + + // optional .bgs.protocol.EntityId account_id = 5; + if (has_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, this->account_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.UpdateFriendStateNotification) +} + +::google::protobuf::uint8* UpdateFriendStateNotification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.UpdateFriendStateNotification) + // required .bgs.protocol.friends.v1.Friend changed_friend = 1; + if (has_changed_friend()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->changed_friend(), target); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->game_account_id(), target); + } + + // optional .bgs.protocol.ProcessId peer = 4; + if (has_peer()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->peer(), target); + } + + // optional .bgs.protocol.EntityId account_id = 5; + if (has_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 5, this->account_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.UpdateFriendStateNotification) + return target; +} + +int UpdateFriendStateNotification::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.friends.v1.Friend changed_friend = 1; + if (has_changed_friend()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->changed_friend()); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account_id()); + } + + // optional .bgs.protocol.ProcessId peer = 4; + if (has_peer()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->peer()); + } + + // optional .bgs.protocol.EntityId account_id = 5; + if (has_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void UpdateFriendStateNotification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const UpdateFriendStateNotification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void UpdateFriendStateNotification::MergeFrom(const UpdateFriendStateNotification& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_changed_friend()) { + mutable_changed_friend()->::bgs::protocol::friends::v1::Friend::MergeFrom(from.changed_friend()); + } + if (from.has_game_account_id()) { + mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id()); + } + if (from.has_peer()) { + mutable_peer()->::bgs::protocol::ProcessId::MergeFrom(from.peer()); + } + if (from.has_account_id()) { + mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void UpdateFriendStateNotification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void UpdateFriendStateNotification::CopyFrom(const UpdateFriendStateNotification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool UpdateFriendStateNotification::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_changed_friend()) { + if (!this->changed_friend().IsInitialized()) return false; + } + if (has_game_account_id()) { + if (!this->game_account_id().IsInitialized()) return false; + } + if (has_peer()) { + if (!this->peer().IsInitialized()) return false; + } + if (has_account_id()) { + if (!this->account_id().IsInitialized()) return false; + } + return true; +} + +void UpdateFriendStateNotification::Swap(UpdateFriendStateNotification* other) { + if (other != this) { + std::swap(changed_friend_, other->changed_friend_); + std::swap(game_account_id_, other->game_account_id_); + std::swap(peer_, other->peer_); + std::swap(account_id_, other->account_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata UpdateFriendStateNotification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = UpdateFriendStateNotification_descriptor_; + metadata.reflection = UpdateFriendStateNotification_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int InvitationNotification::kInvitationFieldNumber; +const int InvitationNotification::kGameAccountIdFieldNumber; +const int InvitationNotification::kReasonFieldNumber; +const int InvitationNotification::kPeerFieldNumber; +const int InvitationNotification::kAccountIdFieldNumber; +#endif // !_MSC_VER + +InvitationNotification::InvitationNotification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.InvitationNotification) +} + +void InvitationNotification::InitAsDefaultInstance() { + invitation_ = const_cast< ::bgs::protocol::Invitation*>(&::bgs::protocol::Invitation::default_instance()); + game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + peer_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance()); + account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +InvitationNotification::InvitationNotification(const InvitationNotification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.InvitationNotification) +} + +void InvitationNotification::SharedCtor() { + _cached_size_ = 0; + invitation_ = NULL; + game_account_id_ = NULL; + reason_ = 0u; + peer_ = NULL; + account_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +InvitationNotification::~InvitationNotification() { + // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.InvitationNotification) + SharedDtor(); +} + +void InvitationNotification::SharedDtor() { + if (this != default_instance_) { + delete invitation_; + delete game_account_id_; + delete peer_; + delete account_id_; + } +} + +void InvitationNotification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* InvitationNotification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return InvitationNotification_descriptor_; +} + +const InvitationNotification& InvitationNotification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto(); + return *default_instance_; +} + +InvitationNotification* InvitationNotification::default_instance_ = NULL; + +InvitationNotification* InvitationNotification::New() const { + return new InvitationNotification; +} + +void InvitationNotification::Clear() { + if (_has_bits_[0 / 32] & 31) { + if (has_invitation()) { + if (invitation_ != NULL) invitation_->::bgs::protocol::Invitation::Clear(); + } + if (has_game_account_id()) { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + } + reason_ = 0u; + if (has_peer()) { + if (peer_ != NULL) peer_->::bgs::protocol::ProcessId::Clear(); + } + if (has_account_id()) { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool InvitationNotification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.InvitationNotification) + 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)) { + // required .bgs.protocol.Invitation invitation = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_invitation())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_game_account_id; + break; + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + case 2: { + if (tag == 18) { + parse_game_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_reason; + break; + } + + // optional uint32 reason = 3 [default = 0]; + case 3: { + if (tag == 24) { + parse_reason: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &reason_))); + set_has_reason(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_peer; + break; + } + + // optional .bgs.protocol.ProcessId peer = 4; + case 4: { + if (tag == 34) { + parse_peer: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_peer())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_account_id; + break; + } + + // optional .bgs.protocol.EntityId account_id = 5; + case 5: { + if (tag == 42) { + parse_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account_id())); + } 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:bgs.protocol.friends.v1.InvitationNotification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.InvitationNotification) + return false; +#undef DO_ +} + +void InvitationNotification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.InvitationNotification) + // required .bgs.protocol.Invitation invitation = 1; + if (has_invitation()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->invitation(), output); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->game_account_id(), output); + } + + // optional uint32 reason = 3 [default = 0]; + if (has_reason()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->reason(), output); + } + + // optional .bgs.protocol.ProcessId peer = 4; + if (has_peer()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->peer(), output); + } + + // optional .bgs.protocol.EntityId account_id = 5; + if (has_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, this->account_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.InvitationNotification) +} + +::google::protobuf::uint8* InvitationNotification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.InvitationNotification) + // required .bgs.protocol.Invitation invitation = 1; + if (has_invitation()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->invitation(), target); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->game_account_id(), target); + } + + // optional uint32 reason = 3 [default = 0]; + if (has_reason()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->reason(), target); + } + + // optional .bgs.protocol.ProcessId peer = 4; + if (has_peer()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->peer(), target); + } + + // optional .bgs.protocol.EntityId account_id = 5; + if (has_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 5, this->account_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.InvitationNotification) + return target; +} + +int InvitationNotification::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.Invitation invitation = 1; + if (has_invitation()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->invitation()); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account_id()); + } + + // optional uint32 reason = 3 [default = 0]; + if (has_reason()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->reason()); + } + + // optional .bgs.protocol.ProcessId peer = 4; + if (has_peer()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->peer()); + } + + // optional .bgs.protocol.EntityId account_id = 5; + if (has_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void InvitationNotification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const InvitationNotification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void InvitationNotification::MergeFrom(const InvitationNotification& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_invitation()) { + mutable_invitation()->::bgs::protocol::Invitation::MergeFrom(from.invitation()); + } + if (from.has_game_account_id()) { + mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id()); + } + if (from.has_reason()) { + set_reason(from.reason()); + } + if (from.has_peer()) { + mutable_peer()->::bgs::protocol::ProcessId::MergeFrom(from.peer()); + } + if (from.has_account_id()) { + mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void InvitationNotification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void InvitationNotification::CopyFrom(const InvitationNotification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool InvitationNotification::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_invitation()) { + if (!this->invitation().IsInitialized()) return false; + } + if (has_game_account_id()) { + if (!this->game_account_id().IsInitialized()) return false; + } + if (has_peer()) { + if (!this->peer().IsInitialized()) return false; + } + if (has_account_id()) { + if (!this->account_id().IsInitialized()) return false; + } + return true; +} + +void InvitationNotification::Swap(InvitationNotification* other) { + if (other != this) { + std::swap(invitation_, other->invitation_); + std::swap(game_account_id_, other->game_account_id_); + std::swap(reason_, other->reason_); + std::swap(peer_, other->peer_); + std::swap(account_id_, other->account_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata InvitationNotification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = InvitationNotification_descriptor_; + metadata.reflection = InvitationNotification_reflection_; + return metadata; +} + + +// =================================================================== + +google::protobuf::ServiceDescriptor const* FriendsService::descriptor() { + protobuf_AssignDescriptorsOnce(); + return FriendsService_descriptor_; +} + +void FriendsService::Subscribe(::bgs::protocol::friends::v1::SubscribeRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.Subscribe(bgs.protocol.friends.v1.SubscribeRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 1, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::friends::v1::SubscribeResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void FriendsService::SendInvitation(::bgs::protocol::SendInvitationRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.SendInvitation(bgs.protocol.SendInvitationRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 2, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void FriendsService::AcceptInvitation(::bgs::protocol::GenericInvitationRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.AcceptInvitation(bgs.protocol.GenericInvitationRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 3, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void FriendsService::RevokeInvitation(::bgs::protocol::GenericInvitationRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.RevokeInvitation(bgs.protocol.GenericInvitationRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 4, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void FriendsService::DeclineInvitation(::bgs::protocol::GenericInvitationRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.DeclineInvitation(bgs.protocol.GenericInvitationRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 5, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void FriendsService::IgnoreInvitation(::bgs::protocol::GenericInvitationRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.IgnoreInvitation(bgs.protocol.GenericInvitationRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 6, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void FriendsService::AssignRole(::bgs::protocol::friends::v1::AssignRoleRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.AssignRole(bgs.protocol.friends.v1.AssignRoleRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 7, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void FriendsService::RemoveFriend(::bgs::protocol::friends::v1::GenericFriendRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.RemoveFriend(bgs.protocol.friends.v1.GenericFriendRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 8, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::friends::v1::GenericFriendResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void FriendsService::ViewFriends(::bgs::protocol::friends::v1::ViewFriendsRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.ViewFriends(bgs.protocol.friends.v1.ViewFriendsRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 9, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::friends::v1::ViewFriendsResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void FriendsService::UpdateFriendState(::bgs::protocol::friends::v1::UpdateFriendStateRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.UpdateFriendState(bgs.protocol.friends.v1.UpdateFriendStateRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 10, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void FriendsService::Unsubscribe(::bgs::protocol::friends::v1::UnsubscribeRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.Unsubscribe(bgs.protocol.friends.v1.UnsubscribeRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 11, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void FriendsService::RevokeAllInvitations(::bgs::protocol::friends::v1::GenericFriendRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.RevokeAllInvitations(bgs.protocol.friends.v1.GenericFriendRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 12, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void FriendsService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) { + switch(methodId) { + case 1: { + ::bgs::protocol::friends::v1::SubscribeRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.Subscribe server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::friends::v1::SubscribeResponse response; + uint32 status = HandleSubscribe(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.Subscribe(bgs.protocol.friends.v1.SubscribeRequest{ %s }) returned bgs.protocol.friends.v1.SubscribeResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 1, token, &response); + else + SendResponse(service_hash_, 1, token, status); + break; + } + case 2: { + ::bgs::protocol::SendInvitationRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.SendInvitation server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleSendInvitation(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.SendInvitation(bgs.protocol.SendInvitationRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 2, token, &response); + else + SendResponse(service_hash_, 2, token, status); + break; + } + case 3: { + ::bgs::protocol::GenericInvitationRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.AcceptInvitation server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleAcceptInvitation(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.AcceptInvitation(bgs.protocol.GenericInvitationRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 3, token, &response); + else + SendResponse(service_hash_, 3, token, status); + break; + } + case 4: { + ::bgs::protocol::GenericInvitationRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.RevokeInvitation server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleRevokeInvitation(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.RevokeInvitation(bgs.protocol.GenericInvitationRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 4, token, &response); + else + SendResponse(service_hash_, 4, token, status); + break; + } + case 5: { + ::bgs::protocol::GenericInvitationRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.DeclineInvitation server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 5, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleDeclineInvitation(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.DeclineInvitation(bgs.protocol.GenericInvitationRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 5, token, &response); + else + SendResponse(service_hash_, 5, token, status); + break; + } + case 6: { + ::bgs::protocol::GenericInvitationRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.IgnoreInvitation server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 6, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleIgnoreInvitation(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.IgnoreInvitation(bgs.protocol.GenericInvitationRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 6, token, &response); + else + SendResponse(service_hash_, 6, token, status); + break; + } + case 7: { + ::bgs::protocol::friends::v1::AssignRoleRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.AssignRole server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 7, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleAssignRole(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.AssignRole(bgs.protocol.friends.v1.AssignRoleRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 7, token, &response); + else + SendResponse(service_hash_, 7, token, status); + break; + } + case 8: { + ::bgs::protocol::friends::v1::GenericFriendRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.RemoveFriend server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 8, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::friends::v1::GenericFriendResponse response; + uint32 status = HandleRemoveFriend(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.RemoveFriend(bgs.protocol.friends.v1.GenericFriendRequest{ %s }) returned bgs.protocol.friends.v1.GenericFriendResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 8, token, &response); + else + SendResponse(service_hash_, 8, token, status); + break; + } + case 9: { + ::bgs::protocol::friends::v1::ViewFriendsRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.ViewFriends server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 9, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::friends::v1::ViewFriendsResponse response; + uint32 status = HandleViewFriends(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.ViewFriends(bgs.protocol.friends.v1.ViewFriendsRequest{ %s }) returned bgs.protocol.friends.v1.ViewFriendsResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 9, token, &response); + else + SendResponse(service_hash_, 9, token, status); + break; + } + case 10: { + ::bgs::protocol::friends::v1::UpdateFriendStateRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.UpdateFriendState server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 10, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleUpdateFriendState(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.UpdateFriendState(bgs.protocol.friends.v1.UpdateFriendStateRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 10, token, &response); + else + SendResponse(service_hash_, 10, token, status); + break; + } + case 11: { + ::bgs::protocol::friends::v1::UnsubscribeRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.Unsubscribe server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 11, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleUnsubscribe(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.Unsubscribe(bgs.protocol.friends.v1.UnsubscribeRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 11, token, &response); + else + SendResponse(service_hash_, 11, token, status); + break; + } + case 12: { + ::bgs::protocol::friends::v1::GenericFriendRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.RevokeAllInvitations server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 12, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleRevokeAllInvitations(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.RevokeAllInvitations(bgs.protocol.friends.v1.GenericFriendRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 12, token, &response); + else + SendResponse(service_hash_, 12, token, status); + break; + } + default: + TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId); + SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD); + break; + } +} + +uint32 FriendsService::HandleSubscribe(::bgs::protocol::friends::v1::SubscribeRequest const* request, ::bgs::protocol::friends::v1::SubscribeResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.Subscribe({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 FriendsService::HandleSendInvitation(::bgs::protocol::SendInvitationRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.SendInvitation({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 FriendsService::HandleAcceptInvitation(::bgs::protocol::GenericInvitationRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.AcceptInvitation({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 FriendsService::HandleRevokeInvitation(::bgs::protocol::GenericInvitationRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.RevokeInvitation({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 FriendsService::HandleDeclineInvitation(::bgs::protocol::GenericInvitationRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.DeclineInvitation({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 FriendsService::HandleIgnoreInvitation(::bgs::protocol::GenericInvitationRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.IgnoreInvitation({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 FriendsService::HandleAssignRole(::bgs::protocol::friends::v1::AssignRoleRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.AssignRole({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 FriendsService::HandleRemoveFriend(::bgs::protocol::friends::v1::GenericFriendRequest const* request, ::bgs::protocol::friends::v1::GenericFriendResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.RemoveFriend({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 FriendsService::HandleViewFriends(::bgs::protocol::friends::v1::ViewFriendsRequest const* request, ::bgs::protocol::friends::v1::ViewFriendsResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.ViewFriends({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 FriendsService::HandleUpdateFriendState(::bgs::protocol::friends::v1::UpdateFriendStateRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.UpdateFriendState({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 FriendsService::HandleUnsubscribe(::bgs::protocol::friends::v1::UnsubscribeRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.Unsubscribe({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 FriendsService::HandleRevokeAllInvitations(::bgs::protocol::friends::v1::GenericFriendRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.RevokeAllInvitations({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +// =================================================================== + +google::protobuf::ServiceDescriptor const* FriendsListener::descriptor() { + protobuf_AssignDescriptorsOnce(); + return FriendsListener_descriptor_; +} + +void FriendsListener::OnFriendAdded(::bgs::protocol::friends::v1::FriendNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsListener.OnFriendAdded(bgs.protocol.friends.v1.FriendNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 1, request); +} + +void FriendsListener::OnFriendRemoved(::bgs::protocol::friends::v1::FriendNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsListener.OnFriendRemoved(bgs.protocol.friends.v1.FriendNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 2, request); +} + +void FriendsListener::OnReceivedInvitationAdded(::bgs::protocol::friends::v1::InvitationNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsListener.OnReceivedInvitationAdded(bgs.protocol.friends.v1.InvitationNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 3, request); +} + +void FriendsListener::OnReceivedInvitationRemoved(::bgs::protocol::friends::v1::InvitationNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsListener.OnReceivedInvitationRemoved(bgs.protocol.friends.v1.InvitationNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 4, request); +} + +void FriendsListener::OnSentInvitationAdded(::bgs::protocol::friends::v1::InvitationNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsListener.OnSentInvitationAdded(bgs.protocol.friends.v1.InvitationNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 5, request); +} + +void FriendsListener::OnSentInvitationRemoved(::bgs::protocol::friends::v1::InvitationNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsListener.OnSentInvitationRemoved(bgs.protocol.friends.v1.InvitationNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 6, request); +} + +void FriendsListener::OnUpdateFriendState(::bgs::protocol::friends::v1::UpdateFriendStateNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsListener.OnUpdateFriendState(bgs.protocol.friends.v1.UpdateFriendStateNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 7, request); +} + +void FriendsListener::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) { + switch(methodId) { + case 1: { + ::bgs::protocol::friends::v1::FriendNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsListener.OnFriendAdded server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnFriendAdded(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsListener.OnFriendAdded(bgs.protocol.friends.v1.FriendNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 1, token, status); + break; + } + case 2: { + ::bgs::protocol::friends::v1::FriendNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsListener.OnFriendRemoved server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnFriendRemoved(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsListener.OnFriendRemoved(bgs.protocol.friends.v1.FriendNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 2, token, status); + break; + } + case 3: { + ::bgs::protocol::friends::v1::InvitationNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsListener.OnReceivedInvitationAdded server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnReceivedInvitationAdded(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsListener.OnReceivedInvitationAdded(bgs.protocol.friends.v1.InvitationNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 3, token, status); + break; + } + case 4: { + ::bgs::protocol::friends::v1::InvitationNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsListener.OnReceivedInvitationRemoved server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnReceivedInvitationRemoved(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsListener.OnReceivedInvitationRemoved(bgs.protocol.friends.v1.InvitationNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 4, token, status); + break; + } + case 5: { + ::bgs::protocol::friends::v1::InvitationNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsListener.OnSentInvitationAdded server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 5, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnSentInvitationAdded(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsListener.OnSentInvitationAdded(bgs.protocol.friends.v1.InvitationNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 5, token, status); + break; + } + case 6: { + ::bgs::protocol::friends::v1::InvitationNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsListener.OnSentInvitationRemoved server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 6, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnSentInvitationRemoved(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsListener.OnSentInvitationRemoved(bgs.protocol.friends.v1.InvitationNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 6, token, status); + break; + } + case 7: { + ::bgs::protocol::friends::v1::UpdateFriendStateNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsListener.OnUpdateFriendState server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 7, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnUpdateFriendState(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsListener.OnUpdateFriendState(bgs.protocol.friends.v1.UpdateFriendStateNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 7, token, status); + break; + } + default: + TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId); + SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD); + break; + } +} + +uint32 FriendsListener::HandleOnFriendAdded(::bgs::protocol::friends::v1::FriendNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsListener.OnFriendAdded({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 FriendsListener::HandleOnFriendRemoved(::bgs::protocol::friends::v1::FriendNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsListener.OnFriendRemoved({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 FriendsListener::HandleOnReceivedInvitationAdded(::bgs::protocol::friends::v1::InvitationNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsListener.OnReceivedInvitationAdded({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 FriendsListener::HandleOnReceivedInvitationRemoved(::bgs::protocol::friends::v1::InvitationNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsListener.OnReceivedInvitationRemoved({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 FriendsListener::HandleOnSentInvitationAdded(::bgs::protocol::friends::v1::InvitationNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsListener.OnSentInvitationAdded({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 FriendsListener::HandleOnSentInvitationRemoved(::bgs::protocol::friends::v1::InvitationNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsListener.OnSentInvitationRemoved({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 FriendsListener::HandleOnUpdateFriendState(::bgs::protocol::friends::v1::UpdateFriendStateNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsListener.OnUpdateFriendState({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace friends +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/friends_service.pb.h b/src/server/proto/Client/friends_service.pb.h new file mode 100644 index 00000000000..9453c1df1d4 --- /dev/null +++ b/src/server/proto/Client/friends_service.pb.h @@ -0,0 +1,2856 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: friends_service.proto + +#ifndef PROTOBUF_friends_5fservice_2eproto__INCLUDED +#define PROTOBUF_friends_5fservice_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include "attribute_types.pb.h" +#include "entity_types.pb.h" +#include "friends_types.pb.h" +#include "invitation_types.pb.h" +#include "role_types.pb.h" +#include "rpc_types.pb.h" +#include "ServiceBase.h" +#include "MessageBuffer.h" +#include +#include +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { +namespace friends { +namespace v1 { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto(); +void protobuf_AssignDesc_friends_5fservice_2eproto(); +void protobuf_ShutdownFile_friends_5fservice_2eproto(); + +class SubscribeRequest; +class SubscribeResponse; +class UnsubscribeRequest; +class GenericFriendRequest; +class GenericFriendResponse; +class AssignRoleRequest; +class ViewFriendsRequest; +class ViewFriendsResponse; +class UpdateFriendStateRequest; +class FriendNotification; +class UpdateFriendStateNotification; +class InvitationNotification; + +// =================================================================== + +class TC_SHARED_API SubscribeRequest : public ::google::protobuf::Message { + public: + SubscribeRequest(); + virtual ~SubscribeRequest(); + + SubscribeRequest(const SubscribeRequest& from); + + inline SubscribeRequest& operator=(const SubscribeRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SubscribeRequest& default_instance(); + + void Swap(SubscribeRequest* other); + + // implements Message ---------------------------------------------- + + SubscribeRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SubscribeRequest& from); + void MergeFrom(const SubscribeRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // required uint64 object_id = 2; + inline bool has_object_id() const; + inline void clear_object_id(); + static const int kObjectIdFieldNumber = 2; + inline ::google::protobuf::uint64 object_id() const; + inline void set_object_id(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.SubscribeRequest) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_object_id(); + inline void clear_has_object_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::google::protobuf::uint64 object_id_; + friend void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto(); + friend void protobuf_AssignDesc_friends_5fservice_2eproto(); + friend void protobuf_ShutdownFile_friends_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static SubscribeRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API SubscribeResponse : public ::google::protobuf::Message { + public: + SubscribeResponse(); + virtual ~SubscribeResponse(); + + SubscribeResponse(const SubscribeResponse& from); + + inline SubscribeResponse& operator=(const SubscribeResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SubscribeResponse& default_instance(); + + void Swap(SubscribeResponse* other); + + // implements Message ---------------------------------------------- + + SubscribeResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SubscribeResponse& from); + void MergeFrom(const SubscribeResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional uint32 max_friends = 1; + inline bool has_max_friends() const; + inline void clear_max_friends(); + static const int kMaxFriendsFieldNumber = 1; + inline ::google::protobuf::uint32 max_friends() const; + inline void set_max_friends(::google::protobuf::uint32 value); + + // optional uint32 max_received_invitations = 2; + inline bool has_max_received_invitations() const; + inline void clear_max_received_invitations(); + static const int kMaxReceivedInvitationsFieldNumber = 2; + inline ::google::protobuf::uint32 max_received_invitations() const; + inline void set_max_received_invitations(::google::protobuf::uint32 value); + + // optional uint32 max_sent_invitations = 3; + inline bool has_max_sent_invitations() const; + inline void clear_max_sent_invitations(); + static const int kMaxSentInvitationsFieldNumber = 3; + inline ::google::protobuf::uint32 max_sent_invitations() const; + inline void set_max_sent_invitations(::google::protobuf::uint32 value); + + // repeated .bgs.protocol.Role role = 4; + inline int role_size() const; + inline void clear_role(); + static const int kRoleFieldNumber = 4; + inline const ::bgs::protocol::Role& role(int index) const; + inline ::bgs::protocol::Role* mutable_role(int index); + inline ::bgs::protocol::Role* add_role(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Role >& + role() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Role >* + mutable_role(); + + // repeated .bgs.protocol.friends.v1.Friend friends = 5; + inline int friends_size() const; + inline void clear_friends(); + static const int kFriendsFieldNumber = 5; + inline const ::bgs::protocol::friends::v1::Friend& friends(int index) const; + inline ::bgs::protocol::friends::v1::Friend* mutable_friends(int index); + inline ::bgs::protocol::friends::v1::Friend* add_friends(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::Friend >& + friends() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::Friend >* + mutable_friends(); + + // repeated .bgs.protocol.Invitation sent_invitations = 6; + inline int sent_invitations_size() const; + inline void clear_sent_invitations(); + static const int kSentInvitationsFieldNumber = 6; + inline const ::bgs::protocol::Invitation& sent_invitations(int index) const; + inline ::bgs::protocol::Invitation* mutable_sent_invitations(int index); + inline ::bgs::protocol::Invitation* add_sent_invitations(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >& + sent_invitations() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >* + mutable_sent_invitations(); + + // repeated .bgs.protocol.Invitation received_invitations = 7; + inline int received_invitations_size() const; + inline void clear_received_invitations(); + static const int kReceivedInvitationsFieldNumber = 7; + inline const ::bgs::protocol::Invitation& received_invitations(int index) const; + inline ::bgs::protocol::Invitation* mutable_received_invitations(int index); + inline ::bgs::protocol::Invitation* add_received_invitations(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >& + received_invitations() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >* + mutable_received_invitations(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.SubscribeResponse) + private: + inline void set_has_max_friends(); + inline void clear_has_max_friends(); + inline void set_has_max_received_invitations(); + inline void clear_has_max_received_invitations(); + inline void set_has_max_sent_invitations(); + inline void clear_has_max_sent_invitations(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 max_friends_; + ::google::protobuf::uint32 max_received_invitations_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Role > role_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::Friend > friends_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation > sent_invitations_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation > received_invitations_; + ::google::protobuf::uint32 max_sent_invitations_; + friend void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto(); + friend void protobuf_AssignDesc_friends_5fservice_2eproto(); + friend void protobuf_ShutdownFile_friends_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static SubscribeResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API UnsubscribeRequest : public ::google::protobuf::Message { + public: + UnsubscribeRequest(); + virtual ~UnsubscribeRequest(); + + UnsubscribeRequest(const UnsubscribeRequest& from); + + inline UnsubscribeRequest& operator=(const UnsubscribeRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const UnsubscribeRequest& default_instance(); + + void Swap(UnsubscribeRequest* other); + + // implements Message ---------------------------------------------- + + UnsubscribeRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const UnsubscribeRequest& from); + void MergeFrom(const UnsubscribeRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // optional uint64 object_id = 2; + inline bool has_object_id() const; + inline void clear_object_id(); + static const int kObjectIdFieldNumber = 2; + inline ::google::protobuf::uint64 object_id() const; + inline void set_object_id(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.UnsubscribeRequest) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_object_id(); + inline void clear_has_object_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::google::protobuf::uint64 object_id_; + friend void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto(); + friend void protobuf_AssignDesc_friends_5fservice_2eproto(); + friend void protobuf_ShutdownFile_friends_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static UnsubscribeRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GenericFriendRequest : public ::google::protobuf::Message { + public: + GenericFriendRequest(); + virtual ~GenericFriendRequest(); + + GenericFriendRequest(const GenericFriendRequest& from); + + inline GenericFriendRequest& operator=(const GenericFriendRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GenericFriendRequest& default_instance(); + + void Swap(GenericFriendRequest* other); + + // implements Message ---------------------------------------------- + + GenericFriendRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GenericFriendRequest& from); + void MergeFrom(const GenericFriendRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // required .bgs.protocol.EntityId target_id = 2; + inline bool has_target_id() const; + inline void clear_target_id(); + static const int kTargetIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& target_id() const; + inline ::bgs::protocol::EntityId* mutable_target_id(); + inline ::bgs::protocol::EntityId* release_target_id(); + inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id); + + // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.GenericFriendRequest) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_target_id(); + inline void clear_has_target_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::bgs::protocol::EntityId* target_id_; + friend void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto(); + friend void protobuf_AssignDesc_friends_5fservice_2eproto(); + friend void protobuf_ShutdownFile_friends_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GenericFriendRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GenericFriendResponse : public ::google::protobuf::Message { + public: + GenericFriendResponse(); + virtual ~GenericFriendResponse(); + + GenericFriendResponse(const GenericFriendResponse& from); + + inline GenericFriendResponse& operator=(const GenericFriendResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GenericFriendResponse& default_instance(); + + void Swap(GenericFriendResponse* other); + + // implements Message ---------------------------------------------- + + GenericFriendResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GenericFriendResponse& from); + void MergeFrom(const GenericFriendResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.friends.v1.Friend target_friend = 1; + inline bool has_target_friend() const; + inline void clear_target_friend(); + static const int kTargetFriendFieldNumber = 1; + inline const ::bgs::protocol::friends::v1::Friend& target_friend() const; + inline ::bgs::protocol::friends::v1::Friend* mutable_target_friend(); + inline ::bgs::protocol::friends::v1::Friend* release_target_friend(); + inline void set_allocated_target_friend(::bgs::protocol::friends::v1::Friend* target_friend); + + // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.GenericFriendResponse) + private: + inline void set_has_target_friend(); + inline void clear_has_target_friend(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::friends::v1::Friend* target_friend_; + friend void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto(); + friend void protobuf_AssignDesc_friends_5fservice_2eproto(); + friend void protobuf_ShutdownFile_friends_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GenericFriendResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API AssignRoleRequest : public ::google::protobuf::Message { + public: + AssignRoleRequest(); + virtual ~AssignRoleRequest(); + + AssignRoleRequest(const AssignRoleRequest& from); + + inline AssignRoleRequest& operator=(const AssignRoleRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AssignRoleRequest& default_instance(); + + void Swap(AssignRoleRequest* other); + + // implements Message ---------------------------------------------- + + AssignRoleRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AssignRoleRequest& from); + void MergeFrom(const AssignRoleRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // required .bgs.protocol.EntityId target_id = 2; + inline bool has_target_id() const; + inline void clear_target_id(); + static const int kTargetIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& target_id() const; + inline ::bgs::protocol::EntityId* mutable_target_id(); + inline ::bgs::protocol::EntityId* release_target_id(); + inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id); + + // repeated int32 role = 3; + inline int role_size() const; + inline void clear_role(); + static const int kRoleFieldNumber = 3; + inline ::google::protobuf::int32 role(int index) const; + inline void set_role(int index, ::google::protobuf::int32 value); + inline void add_role(::google::protobuf::int32 value); + inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& + role() const; + inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* + mutable_role(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.AssignRoleRequest) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_target_id(); + inline void clear_has_target_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::bgs::protocol::EntityId* target_id_; + ::google::protobuf::RepeatedField< ::google::protobuf::int32 > role_; + friend void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto(); + friend void protobuf_AssignDesc_friends_5fservice_2eproto(); + friend void protobuf_ShutdownFile_friends_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static AssignRoleRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ViewFriendsRequest : public ::google::protobuf::Message { + public: + ViewFriendsRequest(); + virtual ~ViewFriendsRequest(); + + ViewFriendsRequest(const ViewFriendsRequest& from); + + inline ViewFriendsRequest& operator=(const ViewFriendsRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ViewFriendsRequest& default_instance(); + + void Swap(ViewFriendsRequest* other); + + // implements Message ---------------------------------------------- + + ViewFriendsRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ViewFriendsRequest& from); + void MergeFrom(const ViewFriendsRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // required .bgs.protocol.EntityId target_id = 2; + inline bool has_target_id() const; + inline void clear_target_id(); + static const int kTargetIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& target_id() const; + inline ::bgs::protocol::EntityId* mutable_target_id(); + inline ::bgs::protocol::EntityId* release_target_id(); + inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id); + + // repeated uint32 role = 3 [packed = true]; + inline int role_size() const; + inline void clear_role(); + static const int kRoleFieldNumber = 3; + inline ::google::protobuf::uint32 role(int index) const; + inline void set_role(int index, ::google::protobuf::uint32 value); + inline void add_role(::google::protobuf::uint32 value); + inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + role() const; + inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_role(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.ViewFriendsRequest) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_target_id(); + inline void clear_has_target_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::bgs::protocol::EntityId* target_id_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > role_; + mutable int _role_cached_byte_size_; + friend void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto(); + friend void protobuf_AssignDesc_friends_5fservice_2eproto(); + friend void protobuf_ShutdownFile_friends_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ViewFriendsRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ViewFriendsResponse : public ::google::protobuf::Message { + public: + ViewFriendsResponse(); + virtual ~ViewFriendsResponse(); + + ViewFriendsResponse(const ViewFriendsResponse& from); + + inline ViewFriendsResponse& operator=(const ViewFriendsResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ViewFriendsResponse& default_instance(); + + void Swap(ViewFriendsResponse* other); + + // implements Message ---------------------------------------------- + + ViewFriendsResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ViewFriendsResponse& from); + void MergeFrom(const ViewFriendsResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.friends.v1.Friend friends = 1; + inline int friends_size() const; + inline void clear_friends(); + static const int kFriendsFieldNumber = 1; + inline const ::bgs::protocol::friends::v1::Friend& friends(int index) const; + inline ::bgs::protocol::friends::v1::Friend* mutable_friends(int index); + inline ::bgs::protocol::friends::v1::Friend* add_friends(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::Friend >& + friends() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::Friend >* + mutable_friends(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.ViewFriendsResponse) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::Friend > friends_; + friend void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto(); + friend void protobuf_AssignDesc_friends_5fservice_2eproto(); + friend void protobuf_ShutdownFile_friends_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ViewFriendsResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API UpdateFriendStateRequest : public ::google::protobuf::Message { + public: + UpdateFriendStateRequest(); + virtual ~UpdateFriendStateRequest(); + + UpdateFriendStateRequest(const UpdateFriendStateRequest& from); + + inline UpdateFriendStateRequest& operator=(const UpdateFriendStateRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const UpdateFriendStateRequest& default_instance(); + + void Swap(UpdateFriendStateRequest* other); + + // implements Message ---------------------------------------------- + + UpdateFriendStateRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const UpdateFriendStateRequest& from); + void MergeFrom(const UpdateFriendStateRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // required .bgs.protocol.EntityId target_id = 2; + inline bool has_target_id() const; + inline void clear_target_id(); + static const int kTargetIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& target_id() const; + inline ::bgs::protocol::EntityId* mutable_target_id(); + inline ::bgs::protocol::EntityId* release_target_id(); + inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id); + + // repeated .bgs.protocol.Attribute attribute = 3; + inline int attribute_size() const; + inline void clear_attribute(); + static const int kAttributeFieldNumber = 3; + inline const ::bgs::protocol::Attribute& attribute(int index) const; + inline ::bgs::protocol::Attribute* mutable_attribute(int index); + inline ::bgs::protocol::Attribute* add_attribute(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& + attribute() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* + mutable_attribute(); + + // optional uint64 attributes_epoch = 4; + inline bool has_attributes_epoch() const; + inline void clear_attributes_epoch(); + static const int kAttributesEpochFieldNumber = 4; + inline ::google::protobuf::uint64 attributes_epoch() const; + inline void set_attributes_epoch(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.UpdateFriendStateRequest) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_target_id(); + inline void clear_has_target_id(); + inline void set_has_attributes_epoch(); + inline void clear_has_attributes_epoch(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::bgs::protocol::EntityId* target_id_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_; + ::google::protobuf::uint64 attributes_epoch_; + friend void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto(); + friend void protobuf_AssignDesc_friends_5fservice_2eproto(); + friend void protobuf_ShutdownFile_friends_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static UpdateFriendStateRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API FriendNotification : public ::google::protobuf::Message { + public: + FriendNotification(); + virtual ~FriendNotification(); + + FriendNotification(const FriendNotification& from); + + inline FriendNotification& operator=(const FriendNotification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const FriendNotification& default_instance(); + + void Swap(FriendNotification* other); + + // implements Message ---------------------------------------------- + + FriendNotification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const FriendNotification& from); + void MergeFrom(const FriendNotification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.friends.v1.Friend target = 1; + inline bool has_target() const; + inline void clear_target(); + static const int kTargetFieldNumber = 1; + inline const ::bgs::protocol::friends::v1::Friend& target() const; + inline ::bgs::protocol::friends::v1::Friend* mutable_target(); + inline ::bgs::protocol::friends::v1::Friend* release_target(); + inline void set_allocated_target(::bgs::protocol::friends::v1::Friend* target); + + // optional .bgs.protocol.EntityId game_account_id = 2; + inline bool has_game_account_id() const; + inline void clear_game_account_id(); + static const int kGameAccountIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& game_account_id() const; + inline ::bgs::protocol::EntityId* mutable_game_account_id(); + inline ::bgs::protocol::EntityId* release_game_account_id(); + inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id); + + // optional .bgs.protocol.ProcessId peer = 4; + inline bool has_peer() const; + inline void clear_peer(); + static const int kPeerFieldNumber = 4; + inline const ::bgs::protocol::ProcessId& peer() const; + inline ::bgs::protocol::ProcessId* mutable_peer(); + inline ::bgs::protocol::ProcessId* release_peer(); + inline void set_allocated_peer(::bgs::protocol::ProcessId* peer); + + // optional .bgs.protocol.EntityId account_id = 5; + inline bool has_account_id() const; + inline void clear_account_id(); + static const int kAccountIdFieldNumber = 5; + inline const ::bgs::protocol::EntityId& account_id() const; + inline ::bgs::protocol::EntityId* mutable_account_id(); + inline ::bgs::protocol::EntityId* release_account_id(); + inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id); + + // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.FriendNotification) + private: + inline void set_has_target(); + inline void clear_has_target(); + inline void set_has_game_account_id(); + inline void clear_has_game_account_id(); + inline void set_has_peer(); + inline void clear_has_peer(); + inline void set_has_account_id(); + inline void clear_has_account_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::friends::v1::Friend* target_; + ::bgs::protocol::EntityId* game_account_id_; + ::bgs::protocol::ProcessId* peer_; + ::bgs::protocol::EntityId* account_id_; + friend void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto(); + friend void protobuf_AssignDesc_friends_5fservice_2eproto(); + friend void protobuf_ShutdownFile_friends_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static FriendNotification* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API UpdateFriendStateNotification : public ::google::protobuf::Message { + public: + UpdateFriendStateNotification(); + virtual ~UpdateFriendStateNotification(); + + UpdateFriendStateNotification(const UpdateFriendStateNotification& from); + + inline UpdateFriendStateNotification& operator=(const UpdateFriendStateNotification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const UpdateFriendStateNotification& default_instance(); + + void Swap(UpdateFriendStateNotification* other); + + // implements Message ---------------------------------------------- + + UpdateFriendStateNotification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const UpdateFriendStateNotification& from); + void MergeFrom(const UpdateFriendStateNotification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.friends.v1.Friend changed_friend = 1; + inline bool has_changed_friend() const; + inline void clear_changed_friend(); + static const int kChangedFriendFieldNumber = 1; + inline const ::bgs::protocol::friends::v1::Friend& changed_friend() const; + inline ::bgs::protocol::friends::v1::Friend* mutable_changed_friend(); + inline ::bgs::protocol::friends::v1::Friend* release_changed_friend(); + inline void set_allocated_changed_friend(::bgs::protocol::friends::v1::Friend* changed_friend); + + // optional .bgs.protocol.EntityId game_account_id = 2; + inline bool has_game_account_id() const; + inline void clear_game_account_id(); + static const int kGameAccountIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& game_account_id() const; + inline ::bgs::protocol::EntityId* mutable_game_account_id(); + inline ::bgs::protocol::EntityId* release_game_account_id(); + inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id); + + // optional .bgs.protocol.ProcessId peer = 4; + inline bool has_peer() const; + inline void clear_peer(); + static const int kPeerFieldNumber = 4; + inline const ::bgs::protocol::ProcessId& peer() const; + inline ::bgs::protocol::ProcessId* mutable_peer(); + inline ::bgs::protocol::ProcessId* release_peer(); + inline void set_allocated_peer(::bgs::protocol::ProcessId* peer); + + // optional .bgs.protocol.EntityId account_id = 5; + inline bool has_account_id() const; + inline void clear_account_id(); + static const int kAccountIdFieldNumber = 5; + inline const ::bgs::protocol::EntityId& account_id() const; + inline ::bgs::protocol::EntityId* mutable_account_id(); + inline ::bgs::protocol::EntityId* release_account_id(); + inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id); + + // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.UpdateFriendStateNotification) + private: + inline void set_has_changed_friend(); + inline void clear_has_changed_friend(); + inline void set_has_game_account_id(); + inline void clear_has_game_account_id(); + inline void set_has_peer(); + inline void clear_has_peer(); + inline void set_has_account_id(); + inline void clear_has_account_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::friends::v1::Friend* changed_friend_; + ::bgs::protocol::EntityId* game_account_id_; + ::bgs::protocol::ProcessId* peer_; + ::bgs::protocol::EntityId* account_id_; + friend void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto(); + friend void protobuf_AssignDesc_friends_5fservice_2eproto(); + friend void protobuf_ShutdownFile_friends_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static UpdateFriendStateNotification* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API InvitationNotification : public ::google::protobuf::Message { + public: + InvitationNotification(); + virtual ~InvitationNotification(); + + InvitationNotification(const InvitationNotification& from); + + inline InvitationNotification& operator=(const InvitationNotification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const InvitationNotification& default_instance(); + + void Swap(InvitationNotification* other); + + // implements Message ---------------------------------------------- + + InvitationNotification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const InvitationNotification& from); + void MergeFrom(const InvitationNotification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.Invitation invitation = 1; + inline bool has_invitation() const; + inline void clear_invitation(); + static const int kInvitationFieldNumber = 1; + inline const ::bgs::protocol::Invitation& invitation() const; + inline ::bgs::protocol::Invitation* mutable_invitation(); + inline ::bgs::protocol::Invitation* release_invitation(); + inline void set_allocated_invitation(::bgs::protocol::Invitation* invitation); + + // optional .bgs.protocol.EntityId game_account_id = 2; + inline bool has_game_account_id() const; + inline void clear_game_account_id(); + static const int kGameAccountIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& game_account_id() const; + inline ::bgs::protocol::EntityId* mutable_game_account_id(); + inline ::bgs::protocol::EntityId* release_game_account_id(); + inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id); + + // optional uint32 reason = 3 [default = 0]; + inline bool has_reason() const; + inline void clear_reason(); + static const int kReasonFieldNumber = 3; + inline ::google::protobuf::uint32 reason() const; + inline void set_reason(::google::protobuf::uint32 value); + + // optional .bgs.protocol.ProcessId peer = 4; + inline bool has_peer() const; + inline void clear_peer(); + static const int kPeerFieldNumber = 4; + inline const ::bgs::protocol::ProcessId& peer() const; + inline ::bgs::protocol::ProcessId* mutable_peer(); + inline ::bgs::protocol::ProcessId* release_peer(); + inline void set_allocated_peer(::bgs::protocol::ProcessId* peer); + + // optional .bgs.protocol.EntityId account_id = 5; + inline bool has_account_id() const; + inline void clear_account_id(); + static const int kAccountIdFieldNumber = 5; + inline const ::bgs::protocol::EntityId& account_id() const; + inline ::bgs::protocol::EntityId* mutable_account_id(); + inline ::bgs::protocol::EntityId* release_account_id(); + inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id); + + // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.InvitationNotification) + private: + inline void set_has_invitation(); + inline void clear_has_invitation(); + inline void set_has_game_account_id(); + inline void clear_has_game_account_id(); + inline void set_has_reason(); + inline void clear_has_reason(); + inline void set_has_peer(); + inline void clear_has_peer(); + inline void set_has_account_id(); + inline void clear_has_account_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::Invitation* invitation_; + ::bgs::protocol::EntityId* game_account_id_; + ::bgs::protocol::ProcessId* peer_; + ::bgs::protocol::EntityId* account_id_; + ::google::protobuf::uint32 reason_; + friend void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto(); + friend void protobuf_AssignDesc_friends_5fservice_2eproto(); + friend void protobuf_ShutdownFile_friends_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static InvitationNotification* default_instance_; +}; +// =================================================================== + +class TC_SHARED_API FriendsService : public ServiceBase +{ + public: + + template + explicit FriendsService(HashSelector) : service_hash_(HashSelector::Result::value) { } + + typedef std::integral_constant OriginalHash; + typedef std::integral_constant NameHash; + + static google::protobuf::ServiceDescriptor const* descriptor(); + + // client methods -------------------------------------------------- + + void Subscribe(::bgs::protocol::friends::v1::SubscribeRequest const* request, std::function responseCallback); + void SendInvitation(::bgs::protocol::SendInvitationRequest const* request, std::function responseCallback); + void AcceptInvitation(::bgs::protocol::GenericInvitationRequest const* request, std::function responseCallback); + void RevokeInvitation(::bgs::protocol::GenericInvitationRequest const* request, std::function responseCallback); + void DeclineInvitation(::bgs::protocol::GenericInvitationRequest const* request, std::function responseCallback); + void IgnoreInvitation(::bgs::protocol::GenericInvitationRequest const* request, std::function responseCallback); + void AssignRole(::bgs::protocol::friends::v1::AssignRoleRequest const* request, std::function responseCallback); + void RemoveFriend(::bgs::protocol::friends::v1::GenericFriendRequest const* request, std::function responseCallback); + void ViewFriends(::bgs::protocol::friends::v1::ViewFriendsRequest const* request, std::function responseCallback); + void UpdateFriendState(::bgs::protocol::friends::v1::UpdateFriendStateRequest const* request, std::function responseCallback); + void Unsubscribe(::bgs::protocol::friends::v1::UnsubscribeRequest const* request, std::function responseCallback); + void RevokeAllInvitations(::bgs::protocol::friends::v1::GenericFriendRequest const* request, std::function responseCallback); + // server methods -------------------------------------------------- + + void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final; + + protected: + virtual uint32 HandleSubscribe(::bgs::protocol::friends::v1::SubscribeRequest const* request, ::bgs::protocol::friends::v1::SubscribeResponse* response); + virtual uint32 HandleSendInvitation(::bgs::protocol::SendInvitationRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleAcceptInvitation(::bgs::protocol::GenericInvitationRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleRevokeInvitation(::bgs::protocol::GenericInvitationRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleDeclineInvitation(::bgs::protocol::GenericInvitationRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleIgnoreInvitation(::bgs::protocol::GenericInvitationRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleAssignRole(::bgs::protocol::friends::v1::AssignRoleRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleRemoveFriend(::bgs::protocol::friends::v1::GenericFriendRequest const* request, ::bgs::protocol::friends::v1::GenericFriendResponse* response); + virtual uint32 HandleViewFriends(::bgs::protocol::friends::v1::ViewFriendsRequest const* request, ::bgs::protocol::friends::v1::ViewFriendsResponse* response); + virtual uint32 HandleUpdateFriendState(::bgs::protocol::friends::v1::UpdateFriendStateRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleUnsubscribe(::bgs::protocol::friends::v1::UnsubscribeRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleRevokeAllInvitations(::bgs::protocol::friends::v1::GenericFriendRequest const* request, ::bgs::protocol::NoData* response); + + private: + uint32 service_hash_; + + GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FriendsService); +}; + +// ------------------------------------------------------------------- + +class TC_SHARED_API FriendsListener : public ServiceBase +{ + public: + + template + explicit FriendsListener(HashSelector) : service_hash_(HashSelector::Result::value) { } + + typedef std::integral_constant OriginalHash; + typedef std::integral_constant NameHash; + + static google::protobuf::ServiceDescriptor const* descriptor(); + + // client methods -------------------------------------------------- + + void OnFriendAdded(::bgs::protocol::friends::v1::FriendNotification const* request); + void OnFriendRemoved(::bgs::protocol::friends::v1::FriendNotification const* request); + void OnReceivedInvitationAdded(::bgs::protocol::friends::v1::InvitationNotification const* request); + void OnReceivedInvitationRemoved(::bgs::protocol::friends::v1::InvitationNotification const* request); + void OnSentInvitationAdded(::bgs::protocol::friends::v1::InvitationNotification const* request); + void OnSentInvitationRemoved(::bgs::protocol::friends::v1::InvitationNotification const* request); + void OnUpdateFriendState(::bgs::protocol::friends::v1::UpdateFriendStateNotification const* request); + // server methods -------------------------------------------------- + + void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final; + + protected: + virtual uint32 HandleOnFriendAdded(::bgs::protocol::friends::v1::FriendNotification const* request); + virtual uint32 HandleOnFriendRemoved(::bgs::protocol::friends::v1::FriendNotification const* request); + virtual uint32 HandleOnReceivedInvitationAdded(::bgs::protocol::friends::v1::InvitationNotification const* request); + virtual uint32 HandleOnReceivedInvitationRemoved(::bgs::protocol::friends::v1::InvitationNotification const* request); + virtual uint32 HandleOnSentInvitationAdded(::bgs::protocol::friends::v1::InvitationNotification const* request); + virtual uint32 HandleOnSentInvitationRemoved(::bgs::protocol::friends::v1::InvitationNotification const* request); + virtual uint32 HandleOnUpdateFriendState(::bgs::protocol::friends::v1::UpdateFriendStateNotification const* request); + + private: + uint32 service_hash_; + + GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FriendsListener); +}; + +// =================================================================== + + +// =================================================================== + +// SubscribeRequest + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool SubscribeRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SubscribeRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void SubscribeRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SubscribeRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& SubscribeRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SubscribeRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* SubscribeRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.SubscribeRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* SubscribeRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void SubscribeRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.SubscribeRequest.agent_id) +} + +// required uint64 object_id = 2; +inline bool SubscribeRequest::has_object_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void SubscribeRequest::set_has_object_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void SubscribeRequest::clear_has_object_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void SubscribeRequest::clear_object_id() { + object_id_ = GOOGLE_ULONGLONG(0); + clear_has_object_id(); +} +inline ::google::protobuf::uint64 SubscribeRequest::object_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SubscribeRequest.object_id) + return object_id_; +} +inline void SubscribeRequest::set_object_id(::google::protobuf::uint64 value) { + set_has_object_id(); + object_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.SubscribeRequest.object_id) +} + +// ------------------------------------------------------------------- + +// SubscribeResponse + +// optional uint32 max_friends = 1; +inline bool SubscribeResponse::has_max_friends() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SubscribeResponse::set_has_max_friends() { + _has_bits_[0] |= 0x00000001u; +} +inline void SubscribeResponse::clear_has_max_friends() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SubscribeResponse::clear_max_friends() { + max_friends_ = 0u; + clear_has_max_friends(); +} +inline ::google::protobuf::uint32 SubscribeResponse::max_friends() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SubscribeResponse.max_friends) + return max_friends_; +} +inline void SubscribeResponse::set_max_friends(::google::protobuf::uint32 value) { + set_has_max_friends(); + max_friends_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.SubscribeResponse.max_friends) +} + +// optional uint32 max_received_invitations = 2; +inline bool SubscribeResponse::has_max_received_invitations() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void SubscribeResponse::set_has_max_received_invitations() { + _has_bits_[0] |= 0x00000002u; +} +inline void SubscribeResponse::clear_has_max_received_invitations() { + _has_bits_[0] &= ~0x00000002u; +} +inline void SubscribeResponse::clear_max_received_invitations() { + max_received_invitations_ = 0u; + clear_has_max_received_invitations(); +} +inline ::google::protobuf::uint32 SubscribeResponse::max_received_invitations() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SubscribeResponse.max_received_invitations) + return max_received_invitations_; +} +inline void SubscribeResponse::set_max_received_invitations(::google::protobuf::uint32 value) { + set_has_max_received_invitations(); + max_received_invitations_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.SubscribeResponse.max_received_invitations) +} + +// optional uint32 max_sent_invitations = 3; +inline bool SubscribeResponse::has_max_sent_invitations() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void SubscribeResponse::set_has_max_sent_invitations() { + _has_bits_[0] |= 0x00000004u; +} +inline void SubscribeResponse::clear_has_max_sent_invitations() { + _has_bits_[0] &= ~0x00000004u; +} +inline void SubscribeResponse::clear_max_sent_invitations() { + max_sent_invitations_ = 0u; + clear_has_max_sent_invitations(); +} +inline ::google::protobuf::uint32 SubscribeResponse::max_sent_invitations() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SubscribeResponse.max_sent_invitations) + return max_sent_invitations_; +} +inline void SubscribeResponse::set_max_sent_invitations(::google::protobuf::uint32 value) { + set_has_max_sent_invitations(); + max_sent_invitations_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.SubscribeResponse.max_sent_invitations) +} + +// repeated .bgs.protocol.Role role = 4; +inline int SubscribeResponse::role_size() const { + return role_.size(); +} +inline void SubscribeResponse::clear_role() { + role_.Clear(); +} +inline const ::bgs::protocol::Role& SubscribeResponse::role(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SubscribeResponse.role) + return role_.Get(index); +} +inline ::bgs::protocol::Role* SubscribeResponse::mutable_role(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.SubscribeResponse.role) + return role_.Mutable(index); +} +inline ::bgs::protocol::Role* SubscribeResponse::add_role() { + // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.SubscribeResponse.role) + return role_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Role >& +SubscribeResponse::role() const { + // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.SubscribeResponse.role) + return role_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Role >* +SubscribeResponse::mutable_role() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.SubscribeResponse.role) + return &role_; +} + +// repeated .bgs.protocol.friends.v1.Friend friends = 5; +inline int SubscribeResponse::friends_size() const { + return friends_.size(); +} +inline void SubscribeResponse::clear_friends() { + friends_.Clear(); +} +inline const ::bgs::protocol::friends::v1::Friend& SubscribeResponse::friends(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SubscribeResponse.friends) + return friends_.Get(index); +} +inline ::bgs::protocol::friends::v1::Friend* SubscribeResponse::mutable_friends(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.SubscribeResponse.friends) + return friends_.Mutable(index); +} +inline ::bgs::protocol::friends::v1::Friend* SubscribeResponse::add_friends() { + // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.SubscribeResponse.friends) + return friends_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::Friend >& +SubscribeResponse::friends() const { + // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.SubscribeResponse.friends) + return friends_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::Friend >* +SubscribeResponse::mutable_friends() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.SubscribeResponse.friends) + return &friends_; +} + +// repeated .bgs.protocol.Invitation sent_invitations = 6; +inline int SubscribeResponse::sent_invitations_size() const { + return sent_invitations_.size(); +} +inline void SubscribeResponse::clear_sent_invitations() { + sent_invitations_.Clear(); +} +inline const ::bgs::protocol::Invitation& SubscribeResponse::sent_invitations(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SubscribeResponse.sent_invitations) + return sent_invitations_.Get(index); +} +inline ::bgs::protocol::Invitation* SubscribeResponse::mutable_sent_invitations(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.SubscribeResponse.sent_invitations) + return sent_invitations_.Mutable(index); +} +inline ::bgs::protocol::Invitation* SubscribeResponse::add_sent_invitations() { + // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.SubscribeResponse.sent_invitations) + return sent_invitations_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >& +SubscribeResponse::sent_invitations() const { + // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.SubscribeResponse.sent_invitations) + return sent_invitations_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >* +SubscribeResponse::mutable_sent_invitations() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.SubscribeResponse.sent_invitations) + return &sent_invitations_; +} + +// repeated .bgs.protocol.Invitation received_invitations = 7; +inline int SubscribeResponse::received_invitations_size() const { + return received_invitations_.size(); +} +inline void SubscribeResponse::clear_received_invitations() { + received_invitations_.Clear(); +} +inline const ::bgs::protocol::Invitation& SubscribeResponse::received_invitations(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SubscribeResponse.received_invitations) + return received_invitations_.Get(index); +} +inline ::bgs::protocol::Invitation* SubscribeResponse::mutable_received_invitations(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.SubscribeResponse.received_invitations) + return received_invitations_.Mutable(index); +} +inline ::bgs::protocol::Invitation* SubscribeResponse::add_received_invitations() { + // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.SubscribeResponse.received_invitations) + return received_invitations_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >& +SubscribeResponse::received_invitations() const { + // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.SubscribeResponse.received_invitations) + return received_invitations_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >* +SubscribeResponse::mutable_received_invitations() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.SubscribeResponse.received_invitations) + return &received_invitations_; +} + +// ------------------------------------------------------------------- + +// UnsubscribeRequest + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool UnsubscribeRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void UnsubscribeRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void UnsubscribeRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void UnsubscribeRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& UnsubscribeRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UnsubscribeRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* UnsubscribeRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.UnsubscribeRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* UnsubscribeRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void UnsubscribeRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.UnsubscribeRequest.agent_id) +} + +// optional uint64 object_id = 2; +inline bool UnsubscribeRequest::has_object_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void UnsubscribeRequest::set_has_object_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void UnsubscribeRequest::clear_has_object_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void UnsubscribeRequest::clear_object_id() { + object_id_ = GOOGLE_ULONGLONG(0); + clear_has_object_id(); +} +inline ::google::protobuf::uint64 UnsubscribeRequest::object_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UnsubscribeRequest.object_id) + return object_id_; +} +inline void UnsubscribeRequest::set_object_id(::google::protobuf::uint64 value) { + set_has_object_id(); + object_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.UnsubscribeRequest.object_id) +} + +// ------------------------------------------------------------------- + +// GenericFriendRequest + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool GenericFriendRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GenericFriendRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void GenericFriendRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GenericFriendRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& GenericFriendRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.GenericFriendRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* GenericFriendRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.GenericFriendRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* GenericFriendRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void GenericFriendRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.GenericFriendRequest.agent_id) +} + +// required .bgs.protocol.EntityId target_id = 2; +inline bool GenericFriendRequest::has_target_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GenericFriendRequest::set_has_target_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void GenericFriendRequest::clear_has_target_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GenericFriendRequest::clear_target_id() { + if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear(); + clear_has_target_id(); +} +inline const ::bgs::protocol::EntityId& GenericFriendRequest::target_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.GenericFriendRequest.target_id) + return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_; +} +inline ::bgs::protocol::EntityId* GenericFriendRequest::mutable_target_id() { + set_has_target_id(); + if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.GenericFriendRequest.target_id) + return target_id_; +} +inline ::bgs::protocol::EntityId* GenericFriendRequest::release_target_id() { + clear_has_target_id(); + ::bgs::protocol::EntityId* temp = target_id_; + target_id_ = NULL; + return temp; +} +inline void GenericFriendRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) { + delete target_id_; + target_id_ = target_id; + if (target_id) { + set_has_target_id(); + } else { + clear_has_target_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.GenericFriendRequest.target_id) +} + +// ------------------------------------------------------------------- + +// GenericFriendResponse + +// optional .bgs.protocol.friends.v1.Friend target_friend = 1; +inline bool GenericFriendResponse::has_target_friend() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GenericFriendResponse::set_has_target_friend() { + _has_bits_[0] |= 0x00000001u; +} +inline void GenericFriendResponse::clear_has_target_friend() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GenericFriendResponse::clear_target_friend() { + if (target_friend_ != NULL) target_friend_->::bgs::protocol::friends::v1::Friend::Clear(); + clear_has_target_friend(); +} +inline const ::bgs::protocol::friends::v1::Friend& GenericFriendResponse::target_friend() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.GenericFriendResponse.target_friend) + return target_friend_ != NULL ? *target_friend_ : *default_instance_->target_friend_; +} +inline ::bgs::protocol::friends::v1::Friend* GenericFriendResponse::mutable_target_friend() { + set_has_target_friend(); + if (target_friend_ == NULL) target_friend_ = new ::bgs::protocol::friends::v1::Friend; + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.GenericFriendResponse.target_friend) + return target_friend_; +} +inline ::bgs::protocol::friends::v1::Friend* GenericFriendResponse::release_target_friend() { + clear_has_target_friend(); + ::bgs::protocol::friends::v1::Friend* temp = target_friend_; + target_friend_ = NULL; + return temp; +} +inline void GenericFriendResponse::set_allocated_target_friend(::bgs::protocol::friends::v1::Friend* target_friend) { + delete target_friend_; + target_friend_ = target_friend; + if (target_friend) { + set_has_target_friend(); + } else { + clear_has_target_friend(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.GenericFriendResponse.target_friend) +} + +// ------------------------------------------------------------------- + +// AssignRoleRequest + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool AssignRoleRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AssignRoleRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void AssignRoleRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AssignRoleRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& AssignRoleRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.AssignRoleRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* AssignRoleRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.AssignRoleRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* AssignRoleRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void AssignRoleRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.AssignRoleRequest.agent_id) +} + +// required .bgs.protocol.EntityId target_id = 2; +inline bool AssignRoleRequest::has_target_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void AssignRoleRequest::set_has_target_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void AssignRoleRequest::clear_has_target_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void AssignRoleRequest::clear_target_id() { + if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear(); + clear_has_target_id(); +} +inline const ::bgs::protocol::EntityId& AssignRoleRequest::target_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.AssignRoleRequest.target_id) + return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_; +} +inline ::bgs::protocol::EntityId* AssignRoleRequest::mutable_target_id() { + set_has_target_id(); + if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.AssignRoleRequest.target_id) + return target_id_; +} +inline ::bgs::protocol::EntityId* AssignRoleRequest::release_target_id() { + clear_has_target_id(); + ::bgs::protocol::EntityId* temp = target_id_; + target_id_ = NULL; + return temp; +} +inline void AssignRoleRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) { + delete target_id_; + target_id_ = target_id; + if (target_id) { + set_has_target_id(); + } else { + clear_has_target_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.AssignRoleRequest.target_id) +} + +// repeated int32 role = 3; +inline int AssignRoleRequest::role_size() const { + return role_.size(); +} +inline void AssignRoleRequest::clear_role() { + role_.Clear(); +} +inline ::google::protobuf::int32 AssignRoleRequest::role(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.AssignRoleRequest.role) + return role_.Get(index); +} +inline void AssignRoleRequest::set_role(int index, ::google::protobuf::int32 value) { + role_.Set(index, value); + // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.AssignRoleRequest.role) +} +inline void AssignRoleRequest::add_role(::google::protobuf::int32 value) { + role_.Add(value); + // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.AssignRoleRequest.role) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& +AssignRoleRequest::role() const { + // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.AssignRoleRequest.role) + return role_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* +AssignRoleRequest::mutable_role() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.AssignRoleRequest.role) + return &role_; +} + +// ------------------------------------------------------------------- + +// ViewFriendsRequest + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool ViewFriendsRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ViewFriendsRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void ViewFriendsRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ViewFriendsRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& ViewFriendsRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.ViewFriendsRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* ViewFriendsRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.ViewFriendsRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* ViewFriendsRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void ViewFriendsRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.ViewFriendsRequest.agent_id) +} + +// required .bgs.protocol.EntityId target_id = 2; +inline bool ViewFriendsRequest::has_target_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ViewFriendsRequest::set_has_target_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void ViewFriendsRequest::clear_has_target_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ViewFriendsRequest::clear_target_id() { + if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear(); + clear_has_target_id(); +} +inline const ::bgs::protocol::EntityId& ViewFriendsRequest::target_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.ViewFriendsRequest.target_id) + return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_; +} +inline ::bgs::protocol::EntityId* ViewFriendsRequest::mutable_target_id() { + set_has_target_id(); + if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.ViewFriendsRequest.target_id) + return target_id_; +} +inline ::bgs::protocol::EntityId* ViewFriendsRequest::release_target_id() { + clear_has_target_id(); + ::bgs::protocol::EntityId* temp = target_id_; + target_id_ = NULL; + return temp; +} +inline void ViewFriendsRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) { + delete target_id_; + target_id_ = target_id; + if (target_id) { + set_has_target_id(); + } else { + clear_has_target_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.ViewFriendsRequest.target_id) +} + +// repeated uint32 role = 3 [packed = true]; +inline int ViewFriendsRequest::role_size() const { + return role_.size(); +} +inline void ViewFriendsRequest::clear_role() { + role_.Clear(); +} +inline ::google::protobuf::uint32 ViewFriendsRequest::role(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.ViewFriendsRequest.role) + return role_.Get(index); +} +inline void ViewFriendsRequest::set_role(int index, ::google::protobuf::uint32 value) { + role_.Set(index, value); + // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.ViewFriendsRequest.role) +} +inline void ViewFriendsRequest::add_role(::google::protobuf::uint32 value) { + role_.Add(value); + // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.ViewFriendsRequest.role) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +ViewFriendsRequest::role() const { + // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.ViewFriendsRequest.role) + return role_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +ViewFriendsRequest::mutable_role() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.ViewFriendsRequest.role) + return &role_; +} + +// ------------------------------------------------------------------- + +// ViewFriendsResponse + +// repeated .bgs.protocol.friends.v1.Friend friends = 1; +inline int ViewFriendsResponse::friends_size() const { + return friends_.size(); +} +inline void ViewFriendsResponse::clear_friends() { + friends_.Clear(); +} +inline const ::bgs::protocol::friends::v1::Friend& ViewFriendsResponse::friends(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.ViewFriendsResponse.friends) + return friends_.Get(index); +} +inline ::bgs::protocol::friends::v1::Friend* ViewFriendsResponse::mutable_friends(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.ViewFriendsResponse.friends) + return friends_.Mutable(index); +} +inline ::bgs::protocol::friends::v1::Friend* ViewFriendsResponse::add_friends() { + // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.ViewFriendsResponse.friends) + return friends_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::Friend >& +ViewFriendsResponse::friends() const { + // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.ViewFriendsResponse.friends) + return friends_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::Friend >* +ViewFriendsResponse::mutable_friends() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.ViewFriendsResponse.friends) + return &friends_; +} + +// ------------------------------------------------------------------- + +// UpdateFriendStateRequest + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool UpdateFriendStateRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void UpdateFriendStateRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void UpdateFriendStateRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void UpdateFriendStateRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& UpdateFriendStateRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UpdateFriendStateRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* UpdateFriendStateRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.UpdateFriendStateRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* UpdateFriendStateRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void UpdateFriendStateRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.UpdateFriendStateRequest.agent_id) +} + +// required .bgs.protocol.EntityId target_id = 2; +inline bool UpdateFriendStateRequest::has_target_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void UpdateFriendStateRequest::set_has_target_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void UpdateFriendStateRequest::clear_has_target_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void UpdateFriendStateRequest::clear_target_id() { + if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear(); + clear_has_target_id(); +} +inline const ::bgs::protocol::EntityId& UpdateFriendStateRequest::target_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UpdateFriendStateRequest.target_id) + return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_; +} +inline ::bgs::protocol::EntityId* UpdateFriendStateRequest::mutable_target_id() { + set_has_target_id(); + if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.UpdateFriendStateRequest.target_id) + return target_id_; +} +inline ::bgs::protocol::EntityId* UpdateFriendStateRequest::release_target_id() { + clear_has_target_id(); + ::bgs::protocol::EntityId* temp = target_id_; + target_id_ = NULL; + return temp; +} +inline void UpdateFriendStateRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) { + delete target_id_; + target_id_ = target_id; + if (target_id) { + set_has_target_id(); + } else { + clear_has_target_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.UpdateFriendStateRequest.target_id) +} + +// repeated .bgs.protocol.Attribute attribute = 3; +inline int UpdateFriendStateRequest::attribute_size() const { + return attribute_.size(); +} +inline void UpdateFriendStateRequest::clear_attribute() { + attribute_.Clear(); +} +inline const ::bgs::protocol::Attribute& UpdateFriendStateRequest::attribute(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UpdateFriendStateRequest.attribute) + return attribute_.Get(index); +} +inline ::bgs::protocol::Attribute* UpdateFriendStateRequest::mutable_attribute(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.UpdateFriendStateRequest.attribute) + return attribute_.Mutable(index); +} +inline ::bgs::protocol::Attribute* UpdateFriendStateRequest::add_attribute() { + // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.UpdateFriendStateRequest.attribute) + return attribute_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& +UpdateFriendStateRequest::attribute() const { + // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.UpdateFriendStateRequest.attribute) + return attribute_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* +UpdateFriendStateRequest::mutable_attribute() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.UpdateFriendStateRequest.attribute) + return &attribute_; +} + +// optional uint64 attributes_epoch = 4; +inline bool UpdateFriendStateRequest::has_attributes_epoch() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void UpdateFriendStateRequest::set_has_attributes_epoch() { + _has_bits_[0] |= 0x00000008u; +} +inline void UpdateFriendStateRequest::clear_has_attributes_epoch() { + _has_bits_[0] &= ~0x00000008u; +} +inline void UpdateFriendStateRequest::clear_attributes_epoch() { + attributes_epoch_ = GOOGLE_ULONGLONG(0); + clear_has_attributes_epoch(); +} +inline ::google::protobuf::uint64 UpdateFriendStateRequest::attributes_epoch() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UpdateFriendStateRequest.attributes_epoch) + return attributes_epoch_; +} +inline void UpdateFriendStateRequest::set_attributes_epoch(::google::protobuf::uint64 value) { + set_has_attributes_epoch(); + attributes_epoch_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.UpdateFriendStateRequest.attributes_epoch) +} + +// ------------------------------------------------------------------- + +// FriendNotification + +// required .bgs.protocol.friends.v1.Friend target = 1; +inline bool FriendNotification::has_target() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void FriendNotification::set_has_target() { + _has_bits_[0] |= 0x00000001u; +} +inline void FriendNotification::clear_has_target() { + _has_bits_[0] &= ~0x00000001u; +} +inline void FriendNotification::clear_target() { + if (target_ != NULL) target_->::bgs::protocol::friends::v1::Friend::Clear(); + clear_has_target(); +} +inline const ::bgs::protocol::friends::v1::Friend& FriendNotification::target() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendNotification.target) + return target_ != NULL ? *target_ : *default_instance_->target_; +} +inline ::bgs::protocol::friends::v1::Friend* FriendNotification::mutable_target() { + set_has_target(); + if (target_ == NULL) target_ = new ::bgs::protocol::friends::v1::Friend; + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendNotification.target) + return target_; +} +inline ::bgs::protocol::friends::v1::Friend* FriendNotification::release_target() { + clear_has_target(); + ::bgs::protocol::friends::v1::Friend* temp = target_; + target_ = NULL; + return temp; +} +inline void FriendNotification::set_allocated_target(::bgs::protocol::friends::v1::Friend* target) { + delete target_; + target_ = target; + if (target) { + set_has_target(); + } else { + clear_has_target(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendNotification.target) +} + +// optional .bgs.protocol.EntityId game_account_id = 2; +inline bool FriendNotification::has_game_account_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void FriendNotification::set_has_game_account_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void FriendNotification::clear_has_game_account_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void FriendNotification::clear_game_account_id() { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_game_account_id(); +} +inline const ::bgs::protocol::EntityId& FriendNotification::game_account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendNotification.game_account_id) + return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_; +} +inline ::bgs::protocol::EntityId* FriendNotification::mutable_game_account_id() { + set_has_game_account_id(); + if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendNotification.game_account_id) + return game_account_id_; +} +inline ::bgs::protocol::EntityId* FriendNotification::release_game_account_id() { + clear_has_game_account_id(); + ::bgs::protocol::EntityId* temp = game_account_id_; + game_account_id_ = NULL; + return temp; +} +inline void FriendNotification::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) { + delete game_account_id_; + game_account_id_ = game_account_id; + if (game_account_id) { + set_has_game_account_id(); + } else { + clear_has_game_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendNotification.game_account_id) +} + +// optional .bgs.protocol.ProcessId peer = 4; +inline bool FriendNotification::has_peer() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void FriendNotification::set_has_peer() { + _has_bits_[0] |= 0x00000004u; +} +inline void FriendNotification::clear_has_peer() { + _has_bits_[0] &= ~0x00000004u; +} +inline void FriendNotification::clear_peer() { + if (peer_ != NULL) peer_->::bgs::protocol::ProcessId::Clear(); + clear_has_peer(); +} +inline const ::bgs::protocol::ProcessId& FriendNotification::peer() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendNotification.peer) + return peer_ != NULL ? *peer_ : *default_instance_->peer_; +} +inline ::bgs::protocol::ProcessId* FriendNotification::mutable_peer() { + set_has_peer(); + if (peer_ == NULL) peer_ = new ::bgs::protocol::ProcessId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendNotification.peer) + return peer_; +} +inline ::bgs::protocol::ProcessId* FriendNotification::release_peer() { + clear_has_peer(); + ::bgs::protocol::ProcessId* temp = peer_; + peer_ = NULL; + return temp; +} +inline void FriendNotification::set_allocated_peer(::bgs::protocol::ProcessId* peer) { + delete peer_; + peer_ = peer; + if (peer) { + set_has_peer(); + } else { + clear_has_peer(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendNotification.peer) +} + +// optional .bgs.protocol.EntityId account_id = 5; +inline bool FriendNotification::has_account_id() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void FriendNotification::set_has_account_id() { + _has_bits_[0] |= 0x00000008u; +} +inline void FriendNotification::clear_has_account_id() { + _has_bits_[0] &= ~0x00000008u; +} +inline void FriendNotification::clear_account_id() { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_account_id(); +} +inline const ::bgs::protocol::EntityId& FriendNotification::account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendNotification.account_id) + return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_; +} +inline ::bgs::protocol::EntityId* FriendNotification::mutable_account_id() { + set_has_account_id(); + if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendNotification.account_id) + return account_id_; +} +inline ::bgs::protocol::EntityId* FriendNotification::release_account_id() { + clear_has_account_id(); + ::bgs::protocol::EntityId* temp = account_id_; + account_id_ = NULL; + return temp; +} +inline void FriendNotification::set_allocated_account_id(::bgs::protocol::EntityId* account_id) { + delete account_id_; + account_id_ = account_id; + if (account_id) { + set_has_account_id(); + } else { + clear_has_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendNotification.account_id) +} + +// ------------------------------------------------------------------- + +// UpdateFriendStateNotification + +// required .bgs.protocol.friends.v1.Friend changed_friend = 1; +inline bool UpdateFriendStateNotification::has_changed_friend() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void UpdateFriendStateNotification::set_has_changed_friend() { + _has_bits_[0] |= 0x00000001u; +} +inline void UpdateFriendStateNotification::clear_has_changed_friend() { + _has_bits_[0] &= ~0x00000001u; +} +inline void UpdateFriendStateNotification::clear_changed_friend() { + if (changed_friend_ != NULL) changed_friend_->::bgs::protocol::friends::v1::Friend::Clear(); + clear_has_changed_friend(); +} +inline const ::bgs::protocol::friends::v1::Friend& UpdateFriendStateNotification::changed_friend() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UpdateFriendStateNotification.changed_friend) + return changed_friend_ != NULL ? *changed_friend_ : *default_instance_->changed_friend_; +} +inline ::bgs::protocol::friends::v1::Friend* UpdateFriendStateNotification::mutable_changed_friend() { + set_has_changed_friend(); + if (changed_friend_ == NULL) changed_friend_ = new ::bgs::protocol::friends::v1::Friend; + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.UpdateFriendStateNotification.changed_friend) + return changed_friend_; +} +inline ::bgs::protocol::friends::v1::Friend* UpdateFriendStateNotification::release_changed_friend() { + clear_has_changed_friend(); + ::bgs::protocol::friends::v1::Friend* temp = changed_friend_; + changed_friend_ = NULL; + return temp; +} +inline void UpdateFriendStateNotification::set_allocated_changed_friend(::bgs::protocol::friends::v1::Friend* changed_friend) { + delete changed_friend_; + changed_friend_ = changed_friend; + if (changed_friend) { + set_has_changed_friend(); + } else { + clear_has_changed_friend(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.UpdateFriendStateNotification.changed_friend) +} + +// optional .bgs.protocol.EntityId game_account_id = 2; +inline bool UpdateFriendStateNotification::has_game_account_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void UpdateFriendStateNotification::set_has_game_account_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void UpdateFriendStateNotification::clear_has_game_account_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void UpdateFriendStateNotification::clear_game_account_id() { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_game_account_id(); +} +inline const ::bgs::protocol::EntityId& UpdateFriendStateNotification::game_account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UpdateFriendStateNotification.game_account_id) + return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_; +} +inline ::bgs::protocol::EntityId* UpdateFriendStateNotification::mutable_game_account_id() { + set_has_game_account_id(); + if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.UpdateFriendStateNotification.game_account_id) + return game_account_id_; +} +inline ::bgs::protocol::EntityId* UpdateFriendStateNotification::release_game_account_id() { + clear_has_game_account_id(); + ::bgs::protocol::EntityId* temp = game_account_id_; + game_account_id_ = NULL; + return temp; +} +inline void UpdateFriendStateNotification::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) { + delete game_account_id_; + game_account_id_ = game_account_id; + if (game_account_id) { + set_has_game_account_id(); + } else { + clear_has_game_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.UpdateFriendStateNotification.game_account_id) +} + +// optional .bgs.protocol.ProcessId peer = 4; +inline bool UpdateFriendStateNotification::has_peer() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void UpdateFriendStateNotification::set_has_peer() { + _has_bits_[0] |= 0x00000004u; +} +inline void UpdateFriendStateNotification::clear_has_peer() { + _has_bits_[0] &= ~0x00000004u; +} +inline void UpdateFriendStateNotification::clear_peer() { + if (peer_ != NULL) peer_->::bgs::protocol::ProcessId::Clear(); + clear_has_peer(); +} +inline const ::bgs::protocol::ProcessId& UpdateFriendStateNotification::peer() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UpdateFriendStateNotification.peer) + return peer_ != NULL ? *peer_ : *default_instance_->peer_; +} +inline ::bgs::protocol::ProcessId* UpdateFriendStateNotification::mutable_peer() { + set_has_peer(); + if (peer_ == NULL) peer_ = new ::bgs::protocol::ProcessId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.UpdateFriendStateNotification.peer) + return peer_; +} +inline ::bgs::protocol::ProcessId* UpdateFriendStateNotification::release_peer() { + clear_has_peer(); + ::bgs::protocol::ProcessId* temp = peer_; + peer_ = NULL; + return temp; +} +inline void UpdateFriendStateNotification::set_allocated_peer(::bgs::protocol::ProcessId* peer) { + delete peer_; + peer_ = peer; + if (peer) { + set_has_peer(); + } else { + clear_has_peer(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.UpdateFriendStateNotification.peer) +} + +// optional .bgs.protocol.EntityId account_id = 5; +inline bool UpdateFriendStateNotification::has_account_id() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void UpdateFriendStateNotification::set_has_account_id() { + _has_bits_[0] |= 0x00000008u; +} +inline void UpdateFriendStateNotification::clear_has_account_id() { + _has_bits_[0] &= ~0x00000008u; +} +inline void UpdateFriendStateNotification::clear_account_id() { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_account_id(); +} +inline const ::bgs::protocol::EntityId& UpdateFriendStateNotification::account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UpdateFriendStateNotification.account_id) + return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_; +} +inline ::bgs::protocol::EntityId* UpdateFriendStateNotification::mutable_account_id() { + set_has_account_id(); + if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.UpdateFriendStateNotification.account_id) + return account_id_; +} +inline ::bgs::protocol::EntityId* UpdateFriendStateNotification::release_account_id() { + clear_has_account_id(); + ::bgs::protocol::EntityId* temp = account_id_; + account_id_ = NULL; + return temp; +} +inline void UpdateFriendStateNotification::set_allocated_account_id(::bgs::protocol::EntityId* account_id) { + delete account_id_; + account_id_ = account_id; + if (account_id) { + set_has_account_id(); + } else { + clear_has_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.UpdateFriendStateNotification.account_id) +} + +// ------------------------------------------------------------------- + +// InvitationNotification + +// required .bgs.protocol.Invitation invitation = 1; +inline bool InvitationNotification::has_invitation() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void InvitationNotification::set_has_invitation() { + _has_bits_[0] |= 0x00000001u; +} +inline void InvitationNotification::clear_has_invitation() { + _has_bits_[0] &= ~0x00000001u; +} +inline void InvitationNotification::clear_invitation() { + if (invitation_ != NULL) invitation_->::bgs::protocol::Invitation::Clear(); + clear_has_invitation(); +} +inline const ::bgs::protocol::Invitation& InvitationNotification::invitation() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.InvitationNotification.invitation) + return invitation_ != NULL ? *invitation_ : *default_instance_->invitation_; +} +inline ::bgs::protocol::Invitation* InvitationNotification::mutable_invitation() { + set_has_invitation(); + if (invitation_ == NULL) invitation_ = new ::bgs::protocol::Invitation; + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.InvitationNotification.invitation) + return invitation_; +} +inline ::bgs::protocol::Invitation* InvitationNotification::release_invitation() { + clear_has_invitation(); + ::bgs::protocol::Invitation* temp = invitation_; + invitation_ = NULL; + return temp; +} +inline void InvitationNotification::set_allocated_invitation(::bgs::protocol::Invitation* invitation) { + delete invitation_; + invitation_ = invitation; + if (invitation) { + set_has_invitation(); + } else { + clear_has_invitation(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.InvitationNotification.invitation) +} + +// optional .bgs.protocol.EntityId game_account_id = 2; +inline bool InvitationNotification::has_game_account_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void InvitationNotification::set_has_game_account_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void InvitationNotification::clear_has_game_account_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void InvitationNotification::clear_game_account_id() { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_game_account_id(); +} +inline const ::bgs::protocol::EntityId& InvitationNotification::game_account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.InvitationNotification.game_account_id) + return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_; +} +inline ::bgs::protocol::EntityId* InvitationNotification::mutable_game_account_id() { + set_has_game_account_id(); + if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.InvitationNotification.game_account_id) + return game_account_id_; +} +inline ::bgs::protocol::EntityId* InvitationNotification::release_game_account_id() { + clear_has_game_account_id(); + ::bgs::protocol::EntityId* temp = game_account_id_; + game_account_id_ = NULL; + return temp; +} +inline void InvitationNotification::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) { + delete game_account_id_; + game_account_id_ = game_account_id; + if (game_account_id) { + set_has_game_account_id(); + } else { + clear_has_game_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.InvitationNotification.game_account_id) +} + +// optional uint32 reason = 3 [default = 0]; +inline bool InvitationNotification::has_reason() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void InvitationNotification::set_has_reason() { + _has_bits_[0] |= 0x00000004u; +} +inline void InvitationNotification::clear_has_reason() { + _has_bits_[0] &= ~0x00000004u; +} +inline void InvitationNotification::clear_reason() { + reason_ = 0u; + clear_has_reason(); +} +inline ::google::protobuf::uint32 InvitationNotification::reason() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.InvitationNotification.reason) + return reason_; +} +inline void InvitationNotification::set_reason(::google::protobuf::uint32 value) { + set_has_reason(); + reason_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.InvitationNotification.reason) +} + +// optional .bgs.protocol.ProcessId peer = 4; +inline bool InvitationNotification::has_peer() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void InvitationNotification::set_has_peer() { + _has_bits_[0] |= 0x00000008u; +} +inline void InvitationNotification::clear_has_peer() { + _has_bits_[0] &= ~0x00000008u; +} +inline void InvitationNotification::clear_peer() { + if (peer_ != NULL) peer_->::bgs::protocol::ProcessId::Clear(); + clear_has_peer(); +} +inline const ::bgs::protocol::ProcessId& InvitationNotification::peer() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.InvitationNotification.peer) + return peer_ != NULL ? *peer_ : *default_instance_->peer_; +} +inline ::bgs::protocol::ProcessId* InvitationNotification::mutable_peer() { + set_has_peer(); + if (peer_ == NULL) peer_ = new ::bgs::protocol::ProcessId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.InvitationNotification.peer) + return peer_; +} +inline ::bgs::protocol::ProcessId* InvitationNotification::release_peer() { + clear_has_peer(); + ::bgs::protocol::ProcessId* temp = peer_; + peer_ = NULL; + return temp; +} +inline void InvitationNotification::set_allocated_peer(::bgs::protocol::ProcessId* peer) { + delete peer_; + peer_ = peer; + if (peer) { + set_has_peer(); + } else { + clear_has_peer(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.InvitationNotification.peer) +} + +// optional .bgs.protocol.EntityId account_id = 5; +inline bool InvitationNotification::has_account_id() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void InvitationNotification::set_has_account_id() { + _has_bits_[0] |= 0x00000010u; +} +inline void InvitationNotification::clear_has_account_id() { + _has_bits_[0] &= ~0x00000010u; +} +inline void InvitationNotification::clear_account_id() { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_account_id(); +} +inline const ::bgs::protocol::EntityId& InvitationNotification::account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.InvitationNotification.account_id) + return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_; +} +inline ::bgs::protocol::EntityId* InvitationNotification::mutable_account_id() { + set_has_account_id(); + if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.InvitationNotification.account_id) + return account_id_; +} +inline ::bgs::protocol::EntityId* InvitationNotification::release_account_id() { + clear_has_account_id(); + ::bgs::protocol::EntityId* temp = account_id_; + account_id_ = NULL; + return temp; +} +inline void InvitationNotification::set_allocated_account_id(::bgs::protocol::EntityId* account_id) { + delete account_id_; + account_id_ = account_id; + if (account_id) { + set_has_account_id(); + } else { + clear_has_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.InvitationNotification.account_id) +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace friends +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_friends_5fservice_2eproto__INCLUDED diff --git a/src/server/proto/Client/friends_types.pb.cc b/src/server/proto/Client/friends_types.pb.cc new file mode 100644 index 00000000000..8017012c08d --- /dev/null +++ b/src/server/proto/Client/friends_types.pb.cc @@ -0,0 +1,1654 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: friends_types.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "friends_types.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { +namespace friends { +namespace v1 { + +namespace { + +const ::google::protobuf::Descriptor* Friend_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Friend_reflection_ = NULL; +const ::google::protobuf::Descriptor* FriendInvitation_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + FriendInvitation_reflection_ = NULL; +const ::google::protobuf::Descriptor* FriendInvitationParams_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + FriendInvitationParams_reflection_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_friends_5ftypes_2eproto() { + protobuf_AddDesc_friends_5ftypes_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "friends_types.proto"); + GOOGLE_CHECK(file != NULL); + Friend_descriptor_ = file->message_type(0); + static const int Friend_offsets_[7] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Friend, account_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Friend, attribute_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Friend, role_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Friend, privileges_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Friend, attributes_epoch_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Friend, full_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Friend, battle_tag_), + }; + Friend_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Friend_descriptor_, + Friend::default_instance_, + Friend_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Friend, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Friend, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Friend)); + FriendInvitation_descriptor_ = file->message_type(1); + static const int FriendInvitation_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitation, first_received_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitation, role_), + }; + FriendInvitation_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + FriendInvitation_descriptor_, + FriendInvitation::default_instance_, + FriendInvitation_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitation, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitation, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(FriendInvitation)); + FriendInvitationParams_descriptor_ = file->message_type(2); + static const int FriendInvitationParams_offsets_[7] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, target_email_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, target_battle_tag_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, inviter_battle_tag_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, inviter_full_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, invitee_display_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, role_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, previous_role_deprecated_), + }; + FriendInvitationParams_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + FriendInvitationParams_descriptor_, + FriendInvitationParams::default_instance_, + FriendInvitationParams_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(FriendInvitationParams)); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_friends_5ftypes_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Friend_descriptor_, &Friend::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + FriendInvitation_descriptor_, &FriendInvitation::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + FriendInvitationParams_descriptor_, &FriendInvitationParams::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_friends_5ftypes_2eproto() { + delete Friend::default_instance_; + delete Friend_reflection_; + delete FriendInvitation::default_instance_; + delete FriendInvitation_reflection_; + delete FriendInvitationParams::default_instance_; + delete FriendInvitationParams_reflection_; +} + +void protobuf_AddDesc_friends_5ftypes_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_invitation_5ftypes_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\023friends_types.proto\022\027bgs.protocol.frie" + "nds.v1\032\025attribute_types.proto\032\022entity_ty" + "pes.proto\032\026invitation_types.proto\"\312\001\n\006Fr" + "iend\022*\n\naccount_id\030\001 \002(\0132\026.bgs.protocol." + "EntityId\022*\n\tattribute\030\002 \003(\0132\027.bgs.protoc" + "ol.Attribute\022\020\n\004role\030\003 \003(\rB\002\020\001\022\025\n\nprivil" + "eges\030\004 \001(\004:\0010\022\030\n\020attributes_epoch\030\005 \001(\004\022" + "\021\n\tfull_name\030\006 \001(\t\022\022\n\nbattle_tag\030\007 \001(\t\"\243" + "\001\n\020FriendInvitation\022\035\n\016first_received\030\001 " + "\001(\010:\005false\022\020\n\004role\030\002 \003(\rB\002\020\0012^\n\021friend_i" + "nvitation\022\030.bgs.protocol.Invitation\030g \001(" + "\0132).bgs.protocol.friends.v1.FriendInvita" + "tion\"\300\002\n\026FriendInvitationParams\022\024\n\014targe" + "t_email\030\001 \001(\t\022\031\n\021target_battle_tag\030\002 \001(\t" + "\022\032\n\022inviter_battle_tag\030\003 \001(\t\022\031\n\021inviter_" + "full_name\030\004 \001(\t\022\034\n\024invitee_display_name\030" + "\005 \001(\t\022\020\n\004role\030\006 \003(\rB\002\020\001\022&\n\030previous_role" + "_deprecated\030\007 \003(\rB\004\020\001\030\0012f\n\rfriend_params" + "\022\036.bgs.protocol.InvitationParams\030g \001(\0132/" + ".bgs.protocol.friends.v1.FriendInvitatio" + "nParamsB/\n\030bnet.protocol.friends.v1B\021Fri" + "endsTypesProtoH\001", 856); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "friends_types.proto", &protobuf_RegisterTypes); + Friend::default_instance_ = new Friend(); + FriendInvitation::default_instance_ = new FriendInvitation(); + FriendInvitationParams::default_instance_ = new FriendInvitationParams(); + Friend::default_instance_->InitAsDefaultInstance(); + FriendInvitation::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::ExtensionSet::RegisterMessageExtension( + &::bgs::protocol::Invitation::default_instance(), + 103, 11, false, false, + &::bgs::protocol::friends::v1::FriendInvitation::default_instance()); + FriendInvitationParams::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::ExtensionSet::RegisterMessageExtension( + &::bgs::protocol::InvitationParams::default_instance(), + 103, 11, false, false, + &::bgs::protocol::friends::v1::FriendInvitationParams::default_instance()); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_friends_5ftypes_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_friends_5ftypes_2eproto { + StaticDescriptorInitializer_friends_5ftypes_2eproto() { + protobuf_AddDesc_friends_5ftypes_2eproto(); + } +} static_descriptor_initializer_friends_5ftypes_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int Friend::kAccountIdFieldNumber; +const int Friend::kAttributeFieldNumber; +const int Friend::kRoleFieldNumber; +const int Friend::kPrivilegesFieldNumber; +const int Friend::kAttributesEpochFieldNumber; +const int Friend::kFullNameFieldNumber; +const int Friend::kBattleTagFieldNumber; +#endif // !_MSC_VER + +Friend::Friend() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.Friend) +} + +void Friend::InitAsDefaultInstance() { + account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +Friend::Friend(const Friend& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.Friend) +} + +void Friend::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + account_id_ = NULL; + privileges_ = GOOGLE_ULONGLONG(0); + attributes_epoch_ = GOOGLE_ULONGLONG(0); + full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Friend::~Friend() { + // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.Friend) + SharedDtor(); +} + +void Friend::SharedDtor() { + if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete full_name_; + } + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete battle_tag_; + } + if (this != default_instance_) { + delete account_id_; + } +} + +void Friend::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Friend::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Friend_descriptor_; +} + +const Friend& Friend::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_friends_5ftypes_2eproto(); + return *default_instance_; +} + +Friend* Friend::default_instance_ = NULL; + +Friend* Friend::New() const { + return new Friend; +} + +void Friend::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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] & 121) { + ZR_(privileges_, attributes_epoch_); + if (has_account_id()) { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_full_name()) { + if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + full_name_->clear(); + } + } + if (has_battle_tag()) { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_->clear(); + } + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + attribute_.Clear(); + role_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Friend::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.Friend) + 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)) { + // required .bgs.protocol.EntityId account_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_attribute; + break; + } + + // repeated .bgs.protocol.Attribute attribute = 2; + case 2: { + if (tag == 18) { + parse_attribute: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_attribute())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_attribute; + if (input->ExpectTag(26)) goto parse_role; + break; + } + + // repeated uint32 role = 3 [packed = true]; + case 3: { + if (tag == 26) { + parse_role: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_role()))); + } else if (tag == 24) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 26, input, this->mutable_role()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_privileges; + break; + } + + // optional uint64 privileges = 4 [default = 0]; + case 4: { + if (tag == 32) { + parse_privileges: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &privileges_))); + set_has_privileges(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_attributes_epoch; + break; + } + + // optional uint64 attributes_epoch = 5; + case 5: { + if (tag == 40) { + parse_attributes_epoch: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &attributes_epoch_))); + set_has_attributes_epoch(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_full_name; + break; + } + + // optional string full_name = 6; + case 6: { + if (tag == 50) { + parse_full_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_full_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->full_name().data(), this->full_name().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "full_name"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(58)) goto parse_battle_tag; + break; + } + + // optional string battle_tag = 7; + case 7: { + if (tag == 58) { + parse_battle_tag: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_battle_tag())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->battle_tag().data(), this->battle_tag().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "battle_tag"); + } 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:bgs.protocol.friends.v1.Friend) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.Friend) + return false; +#undef DO_ +} + +void Friend::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.Friend) + // required .bgs.protocol.EntityId account_id = 1; + if (has_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->account_id(), output); + } + + // repeated .bgs.protocol.Attribute attribute = 2; + for (int i = 0; i < this->attribute_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->attribute(i), output); + } + + // repeated uint32 role = 3 [packed = true]; + if (this->role_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(3, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_role_cached_byte_size_); + } + for (int i = 0; i < this->role_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag( + this->role(i), output); + } + + // optional uint64 privileges = 4 [default = 0]; + if (has_privileges()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->privileges(), output); + } + + // optional uint64 attributes_epoch = 5; + if (has_attributes_epoch()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(5, this->attributes_epoch(), output); + } + + // optional string full_name = 6; + if (has_full_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->full_name().data(), this->full_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "full_name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 6, this->full_name(), output); + } + + // optional string battle_tag = 7; + if (has_battle_tag()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->battle_tag().data(), this->battle_tag().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "battle_tag"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 7, this->battle_tag(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.Friend) +} + +::google::protobuf::uint8* Friend::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.Friend) + // required .bgs.protocol.EntityId account_id = 1; + if (has_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->account_id(), target); + } + + // repeated .bgs.protocol.Attribute attribute = 2; + for (int i = 0; i < this->attribute_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->attribute(i), target); + } + + // repeated uint32 role = 3 [packed = true]; + if (this->role_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 3, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _role_cached_byte_size_, target); + } + for (int i = 0; i < this->role_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32NoTagToArray(this->role(i), target); + } + + // optional uint64 privileges = 4 [default = 0]; + if (has_privileges()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->privileges(), target); + } + + // optional uint64 attributes_epoch = 5; + if (has_attributes_epoch()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(5, this->attributes_epoch(), target); + } + + // optional string full_name = 6; + if (has_full_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->full_name().data(), this->full_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "full_name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 6, this->full_name(), target); + } + + // optional string battle_tag = 7; + if (has_battle_tag()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->battle_tag().data(), this->battle_tag().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "battle_tag"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 7, this->battle_tag(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.Friend) + return target; +} + +int Friend::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.EntityId account_id = 1; + if (has_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account_id()); + } + + // optional uint64 privileges = 4 [default = 0]; + if (has_privileges()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->privileges()); + } + + // optional uint64 attributes_epoch = 5; + if (has_attributes_epoch()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->attributes_epoch()); + } + + // optional string full_name = 6; + if (has_full_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->full_name()); + } + + // optional string battle_tag = 7; + if (has_battle_tag()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->battle_tag()); + } + + } + // repeated .bgs.protocol.Attribute attribute = 2; + total_size += 1 * this->attribute_size(); + for (int i = 0; i < this->attribute_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->attribute(i)); + } + + // repeated uint32 role = 3 [packed = true]; + { + int data_size = 0; + for (int i = 0; i < this->role_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->role(i)); + } + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _role_cached_byte_size_ = data_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_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 Friend::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Friend* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Friend::MergeFrom(const Friend& from) { + GOOGLE_CHECK_NE(&from, this); + attribute_.MergeFrom(from.attribute_); + role_.MergeFrom(from.role_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_account_id()) { + mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id()); + } + if (from.has_privileges()) { + set_privileges(from.privileges()); + } + if (from.has_attributes_epoch()) { + set_attributes_epoch(from.attributes_epoch()); + } + if (from.has_full_name()) { + set_full_name(from.full_name()); + } + if (from.has_battle_tag()) { + set_battle_tag(from.battle_tag()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Friend::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Friend::CopyFrom(const Friend& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Friend::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_account_id()) { + if (!this->account_id().IsInitialized()) return false; + } + if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false; + return true; +} + +void Friend::Swap(Friend* other) { + if (other != this) { + std::swap(account_id_, other->account_id_); + attribute_.Swap(&other->attribute_); + role_.Swap(&other->role_); + std::swap(privileges_, other->privileges_); + std::swap(attributes_epoch_, other->attributes_epoch_); + std::swap(full_name_, other->full_name_); + std::swap(battle_tag_, other->battle_tag_); + 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 Friend::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Friend_descriptor_; + metadata.reflection = Friend_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int FriendInvitation::kFirstReceivedFieldNumber; +const int FriendInvitation::kRoleFieldNumber; +#endif // !_MSC_VER + +#ifndef _MSC_VER +const int FriendInvitation::kFriendInvitationFieldNumber; +#endif +::google::protobuf::internal::ExtensionIdentifier< ::bgs::protocol::Invitation, + ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::friends::v1::FriendInvitation >, 11, false > + FriendInvitation::friend_invitation(kFriendInvitationFieldNumber, ::bgs::protocol::friends::v1::FriendInvitation::default_instance()); +FriendInvitation::FriendInvitation() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.FriendInvitation) +} + +void FriendInvitation::InitAsDefaultInstance() { +} + +FriendInvitation::FriendInvitation(const FriendInvitation& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.FriendInvitation) +} + +void FriendInvitation::SharedCtor() { + _cached_size_ = 0; + first_received_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +FriendInvitation::~FriendInvitation() { + // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.FriendInvitation) + SharedDtor(); +} + +void FriendInvitation::SharedDtor() { + if (this != default_instance_) { + } +} + +void FriendInvitation::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* FriendInvitation::descriptor() { + protobuf_AssignDescriptorsOnce(); + return FriendInvitation_descriptor_; +} + +const FriendInvitation& FriendInvitation::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_friends_5ftypes_2eproto(); + return *default_instance_; +} + +FriendInvitation* FriendInvitation::default_instance_ = NULL; + +FriendInvitation* FriendInvitation::New() const { + return new FriendInvitation; +} + +void FriendInvitation::Clear() { + first_received_ = false; + role_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool FriendInvitation::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.FriendInvitation) + 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 first_received = 1 [default = false]; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &first_received_))); + set_has_first_received(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_role; + break; + } + + // repeated uint32 role = 2 [packed = true]; + case 2: { + if (tag == 18) { + parse_role: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_role()))); + } else if (tag == 16) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 18, input, this->mutable_role()))); + } 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:bgs.protocol.friends.v1.FriendInvitation) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.FriendInvitation) + return false; +#undef DO_ +} + +void FriendInvitation::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.FriendInvitation) + // optional bool first_received = 1 [default = false]; + if (has_first_received()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->first_received(), output); + } + + // repeated uint32 role = 2 [packed = true]; + if (this->role_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(2, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_role_cached_byte_size_); + } + for (int i = 0; i < this->role_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag( + this->role(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.FriendInvitation) +} + +::google::protobuf::uint8* FriendInvitation::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.FriendInvitation) + // optional bool first_received = 1 [default = false]; + if (has_first_received()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->first_received(), target); + } + + // repeated uint32 role = 2 [packed = true]; + if (this->role_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 2, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _role_cached_byte_size_, target); + } + for (int i = 0; i < this->role_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32NoTagToArray(this->role(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.FriendInvitation) + return target; +} + +int FriendInvitation::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional bool first_received = 1 [default = false]; + if (has_first_received()) { + total_size += 1 + 1; + } + + } + // repeated uint32 role = 2 [packed = true]; + { + int data_size = 0; + for (int i = 0; i < this->role_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->role(i)); + } + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _role_cached_byte_size_ = data_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_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 FriendInvitation::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const FriendInvitation* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void FriendInvitation::MergeFrom(const FriendInvitation& from) { + GOOGLE_CHECK_NE(&from, this); + role_.MergeFrom(from.role_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_first_received()) { + set_first_received(from.first_received()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void FriendInvitation::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FriendInvitation::CopyFrom(const FriendInvitation& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FriendInvitation::IsInitialized() const { + + return true; +} + +void FriendInvitation::Swap(FriendInvitation* other) { + if (other != this) { + std::swap(first_received_, other->first_received_); + role_.Swap(&other->role_); + 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 FriendInvitation::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = FriendInvitation_descriptor_; + metadata.reflection = FriendInvitation_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int FriendInvitationParams::kTargetEmailFieldNumber; +const int FriendInvitationParams::kTargetBattleTagFieldNumber; +const int FriendInvitationParams::kInviterBattleTagFieldNumber; +const int FriendInvitationParams::kInviterFullNameFieldNumber; +const int FriendInvitationParams::kInviteeDisplayNameFieldNumber; +const int FriendInvitationParams::kRoleFieldNumber; +const int FriendInvitationParams::kPreviousRoleDeprecatedFieldNumber; +#endif // !_MSC_VER + +#ifndef _MSC_VER +const int FriendInvitationParams::kFriendParamsFieldNumber; +#endif +::google::protobuf::internal::ExtensionIdentifier< ::bgs::protocol::InvitationParams, + ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::friends::v1::FriendInvitationParams >, 11, false > + FriendInvitationParams::friend_params(kFriendParamsFieldNumber, ::bgs::protocol::friends::v1::FriendInvitationParams::default_instance()); +FriendInvitationParams::FriendInvitationParams() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.FriendInvitationParams) +} + +void FriendInvitationParams::InitAsDefaultInstance() { +} + +FriendInvitationParams::FriendInvitationParams(const FriendInvitationParams& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.FriendInvitationParams) +} + +void FriendInvitationParams::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + target_email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + target_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + inviter_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + inviter_full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + invitee_display_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +FriendInvitationParams::~FriendInvitationParams() { + // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.FriendInvitationParams) + SharedDtor(); +} + +void FriendInvitationParams::SharedDtor() { + if (target_email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete target_email_; + } + if (target_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete target_battle_tag_; + } + if (inviter_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete inviter_battle_tag_; + } + if (inviter_full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete inviter_full_name_; + } + if (invitee_display_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete invitee_display_name_; + } + if (this != default_instance_) { + } +} + +void FriendInvitationParams::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* FriendInvitationParams::descriptor() { + protobuf_AssignDescriptorsOnce(); + return FriendInvitationParams_descriptor_; +} + +const FriendInvitationParams& FriendInvitationParams::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_friends_5ftypes_2eproto(); + return *default_instance_; +} + +FriendInvitationParams* FriendInvitationParams::default_instance_ = NULL; + +FriendInvitationParams* FriendInvitationParams::New() const { + return new FriendInvitationParams; +} + +void FriendInvitationParams::Clear() { + if (_has_bits_[0 / 32] & 31) { + if (has_target_email()) { + if (target_email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + target_email_->clear(); + } + } + if (has_target_battle_tag()) { + if (target_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + target_battle_tag_->clear(); + } + } + if (has_inviter_battle_tag()) { + if (inviter_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + inviter_battle_tag_->clear(); + } + } + if (has_inviter_full_name()) { + if (inviter_full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + inviter_full_name_->clear(); + } + } + if (has_invitee_display_name()) { + if (invitee_display_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitee_display_name_->clear(); + } + } + } + role_.Clear(); + previous_role_deprecated_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool FriendInvitationParams::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.FriendInvitationParams) + 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 target_email = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_target_email())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->target_email().data(), this->target_email().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "target_email"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_target_battle_tag; + break; + } + + // optional string target_battle_tag = 2; + case 2: { + if (tag == 18) { + parse_target_battle_tag: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_target_battle_tag())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->target_battle_tag().data(), this->target_battle_tag().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "target_battle_tag"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_inviter_battle_tag; + break; + } + + // optional string inviter_battle_tag = 3; + case 3: { + if (tag == 26) { + parse_inviter_battle_tag: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_inviter_battle_tag())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->inviter_battle_tag().data(), this->inviter_battle_tag().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "inviter_battle_tag"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_inviter_full_name; + break; + } + + // optional string inviter_full_name = 4; + case 4: { + if (tag == 34) { + parse_inviter_full_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_inviter_full_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->inviter_full_name().data(), this->inviter_full_name().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "inviter_full_name"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_invitee_display_name; + break; + } + + // optional string invitee_display_name = 5; + case 5: { + if (tag == 42) { + parse_invitee_display_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_invitee_display_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->invitee_display_name().data(), this->invitee_display_name().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "invitee_display_name"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_role; + break; + } + + // repeated uint32 role = 6 [packed = true]; + case 6: { + if (tag == 50) { + parse_role: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_role()))); + } else if (tag == 48) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 50, input, this->mutable_role()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(58)) goto parse_previous_role_deprecated; + break; + } + + // repeated uint32 previous_role_deprecated = 7 [packed = true, deprecated = true]; + case 7: { + if (tag == 58) { + parse_previous_role_deprecated: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_previous_role_deprecated()))); + } else if (tag == 56) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 58, input, this->mutable_previous_role_deprecated()))); + } 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:bgs.protocol.friends.v1.FriendInvitationParams) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.FriendInvitationParams) + return false; +#undef DO_ +} + +void FriendInvitationParams::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.FriendInvitationParams) + // optional string target_email = 1; + if (has_target_email()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->target_email().data(), this->target_email().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "target_email"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->target_email(), output); + } + + // optional string target_battle_tag = 2; + if (has_target_battle_tag()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->target_battle_tag().data(), this->target_battle_tag().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "target_battle_tag"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->target_battle_tag(), output); + } + + // optional string inviter_battle_tag = 3; + if (has_inviter_battle_tag()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->inviter_battle_tag().data(), this->inviter_battle_tag().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "inviter_battle_tag"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->inviter_battle_tag(), output); + } + + // optional string inviter_full_name = 4; + if (has_inviter_full_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->inviter_full_name().data(), this->inviter_full_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "inviter_full_name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 4, this->inviter_full_name(), output); + } + + // optional string invitee_display_name = 5; + if (has_invitee_display_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->invitee_display_name().data(), this->invitee_display_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "invitee_display_name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 5, this->invitee_display_name(), output); + } + + // repeated uint32 role = 6 [packed = true]; + if (this->role_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(6, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_role_cached_byte_size_); + } + for (int i = 0; i < this->role_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag( + this->role(i), output); + } + + // repeated uint32 previous_role_deprecated = 7 [packed = true, deprecated = true]; + if (this->previous_role_deprecated_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(7, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_previous_role_deprecated_cached_byte_size_); + } + for (int i = 0; i < this->previous_role_deprecated_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag( + this->previous_role_deprecated(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.FriendInvitationParams) +} + +::google::protobuf::uint8* FriendInvitationParams::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.FriendInvitationParams) + // optional string target_email = 1; + if (has_target_email()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->target_email().data(), this->target_email().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "target_email"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->target_email(), target); + } + + // optional string target_battle_tag = 2; + if (has_target_battle_tag()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->target_battle_tag().data(), this->target_battle_tag().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "target_battle_tag"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->target_battle_tag(), target); + } + + // optional string inviter_battle_tag = 3; + if (has_inviter_battle_tag()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->inviter_battle_tag().data(), this->inviter_battle_tag().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "inviter_battle_tag"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->inviter_battle_tag(), target); + } + + // optional string inviter_full_name = 4; + if (has_inviter_full_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->inviter_full_name().data(), this->inviter_full_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "inviter_full_name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->inviter_full_name(), target); + } + + // optional string invitee_display_name = 5; + if (has_invitee_display_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->invitee_display_name().data(), this->invitee_display_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "invitee_display_name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 5, this->invitee_display_name(), target); + } + + // repeated uint32 role = 6 [packed = true]; + if (this->role_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 6, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _role_cached_byte_size_, target); + } + for (int i = 0; i < this->role_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32NoTagToArray(this->role(i), target); + } + + // repeated uint32 previous_role_deprecated = 7 [packed = true, deprecated = true]; + if (this->previous_role_deprecated_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 7, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _previous_role_deprecated_cached_byte_size_, target); + } + for (int i = 0; i < this->previous_role_deprecated_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32NoTagToArray(this->previous_role_deprecated(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.FriendInvitationParams) + return target; +} + +int FriendInvitationParams::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional string target_email = 1; + if (has_target_email()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->target_email()); + } + + // optional string target_battle_tag = 2; + if (has_target_battle_tag()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->target_battle_tag()); + } + + // optional string inviter_battle_tag = 3; + if (has_inviter_battle_tag()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->inviter_battle_tag()); + } + + // optional string inviter_full_name = 4; + if (has_inviter_full_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->inviter_full_name()); + } + + // optional string invitee_display_name = 5; + if (has_invitee_display_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->invitee_display_name()); + } + + } + // repeated uint32 role = 6 [packed = true]; + { + int data_size = 0; + for (int i = 0; i < this->role_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->role(i)); + } + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _role_cached_byte_size_ = data_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + // repeated uint32 previous_role_deprecated = 7 [packed = true, deprecated = true]; + { + int data_size = 0; + for (int i = 0; i < this->previous_role_deprecated_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->previous_role_deprecated(i)); + } + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _previous_role_deprecated_cached_byte_size_ = data_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_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 FriendInvitationParams::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const FriendInvitationParams* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void FriendInvitationParams::MergeFrom(const FriendInvitationParams& from) { + GOOGLE_CHECK_NE(&from, this); + role_.MergeFrom(from.role_); + previous_role_deprecated_.MergeFrom(from.previous_role_deprecated_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_target_email()) { + set_target_email(from.target_email()); + } + if (from.has_target_battle_tag()) { + set_target_battle_tag(from.target_battle_tag()); + } + if (from.has_inviter_battle_tag()) { + set_inviter_battle_tag(from.inviter_battle_tag()); + } + if (from.has_inviter_full_name()) { + set_inviter_full_name(from.inviter_full_name()); + } + if (from.has_invitee_display_name()) { + set_invitee_display_name(from.invitee_display_name()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void FriendInvitationParams::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FriendInvitationParams::CopyFrom(const FriendInvitationParams& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FriendInvitationParams::IsInitialized() const { + + return true; +} + +void FriendInvitationParams::Swap(FriendInvitationParams* other) { + if (other != this) { + std::swap(target_email_, other->target_email_); + std::swap(target_battle_tag_, other->target_battle_tag_); + std::swap(inviter_battle_tag_, other->inviter_battle_tag_); + std::swap(inviter_full_name_, other->inviter_full_name_); + std::swap(invitee_display_name_, other->invitee_display_name_); + role_.Swap(&other->role_); + previous_role_deprecated_.Swap(&other->previous_role_deprecated_); + 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 FriendInvitationParams::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = FriendInvitationParams_descriptor_; + metadata.reflection = FriendInvitationParams_reflection_; + return metadata; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace friends +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/friends_types.pb.h b/src/server/proto/Client/friends_types.pb.h new file mode 100644 index 00000000000..644d0a5b8db --- /dev/null +++ b/src/server/proto/Client/friends_types.pb.h @@ -0,0 +1,1310 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: friends_types.proto + +#ifndef PROTOBUF_friends_5ftypes_2eproto__INCLUDED +#define PROTOBUF_friends_5ftypes_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include "attribute_types.pb.h" +#include "entity_types.pb.h" +#include "invitation_types.pb.h" +#include "Define.h" // for TRINITY_SHARED_API +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { +namespace friends { +namespace v1 { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_friends_5ftypes_2eproto(); +void protobuf_AssignDesc_friends_5ftypes_2eproto(); +void protobuf_ShutdownFile_friends_5ftypes_2eproto(); + +class Friend; +class FriendInvitation; +class FriendInvitationParams; + +// =================================================================== + +class TC_SHARED_API Friend : public ::google::protobuf::Message { + public: + Friend(); + virtual ~Friend(); + + Friend(const Friend& from); + + inline Friend& operator=(const Friend& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Friend& default_instance(); + + void Swap(Friend* other); + + // implements Message ---------------------------------------------- + + Friend* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Friend& from); + void MergeFrom(const Friend& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.EntityId account_id = 1; + inline bool has_account_id() const; + inline void clear_account_id(); + static const int kAccountIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& account_id() const; + inline ::bgs::protocol::EntityId* mutable_account_id(); + inline ::bgs::protocol::EntityId* release_account_id(); + inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id); + + // repeated .bgs.protocol.Attribute attribute = 2; + inline int attribute_size() const; + inline void clear_attribute(); + static const int kAttributeFieldNumber = 2; + inline const ::bgs::protocol::Attribute& attribute(int index) const; + inline ::bgs::protocol::Attribute* mutable_attribute(int index); + inline ::bgs::protocol::Attribute* add_attribute(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& + attribute() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* + mutable_attribute(); + + // repeated uint32 role = 3 [packed = true]; + inline int role_size() const; + inline void clear_role(); + static const int kRoleFieldNumber = 3; + inline ::google::protobuf::uint32 role(int index) const; + inline void set_role(int index, ::google::protobuf::uint32 value); + inline void add_role(::google::protobuf::uint32 value); + inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + role() const; + inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_role(); + + // optional uint64 privileges = 4 [default = 0]; + inline bool has_privileges() const; + inline void clear_privileges(); + static const int kPrivilegesFieldNumber = 4; + inline ::google::protobuf::uint64 privileges() const; + inline void set_privileges(::google::protobuf::uint64 value); + + // optional uint64 attributes_epoch = 5; + inline bool has_attributes_epoch() const; + inline void clear_attributes_epoch(); + static const int kAttributesEpochFieldNumber = 5; + inline ::google::protobuf::uint64 attributes_epoch() const; + inline void set_attributes_epoch(::google::protobuf::uint64 value); + + // optional string full_name = 6; + inline bool has_full_name() const; + inline void clear_full_name(); + static const int kFullNameFieldNumber = 6; + inline const ::std::string& full_name() const; + inline void set_full_name(const ::std::string& value); + inline void set_full_name(const char* value); + inline void set_full_name(const char* value, size_t size); + inline ::std::string* mutable_full_name(); + inline ::std::string* release_full_name(); + inline void set_allocated_full_name(::std::string* full_name); + + // optional string battle_tag = 7; + inline bool has_battle_tag() const; + inline void clear_battle_tag(); + static const int kBattleTagFieldNumber = 7; + inline const ::std::string& battle_tag() const; + inline void set_battle_tag(const ::std::string& value); + inline void set_battle_tag(const char* value); + inline void set_battle_tag(const char* value, size_t size); + inline ::std::string* mutable_battle_tag(); + inline ::std::string* release_battle_tag(); + inline void set_allocated_battle_tag(::std::string* battle_tag); + + // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.Friend) + private: + inline void set_has_account_id(); + inline void clear_has_account_id(); + inline void set_has_privileges(); + inline void clear_has_privileges(); + inline void set_has_attributes_epoch(); + inline void clear_has_attributes_epoch(); + inline void set_has_full_name(); + inline void clear_has_full_name(); + inline void set_has_battle_tag(); + inline void clear_has_battle_tag(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* account_id_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > role_; + mutable int _role_cached_byte_size_; + ::google::protobuf::uint64 privileges_; + ::google::protobuf::uint64 attributes_epoch_; + ::std::string* full_name_; + ::std::string* battle_tag_; + friend void TC_SHARED_API protobuf_AddDesc_friends_5ftypes_2eproto(); + friend void protobuf_AssignDesc_friends_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_friends_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static Friend* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API FriendInvitation : public ::google::protobuf::Message { + public: + FriendInvitation(); + virtual ~FriendInvitation(); + + FriendInvitation(const FriendInvitation& from); + + inline FriendInvitation& operator=(const FriendInvitation& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const FriendInvitation& default_instance(); + + void Swap(FriendInvitation* other); + + // implements Message ---------------------------------------------- + + FriendInvitation* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const FriendInvitation& from); + void MergeFrom(const FriendInvitation& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional bool first_received = 1 [default = false]; + inline bool has_first_received() const; + inline void clear_first_received(); + static const int kFirstReceivedFieldNumber = 1; + inline bool first_received() const; + inline void set_first_received(bool value); + + // repeated uint32 role = 2 [packed = true]; + inline int role_size() const; + inline void clear_role(); + static const int kRoleFieldNumber = 2; + inline ::google::protobuf::uint32 role(int index) const; + inline void set_role(int index, ::google::protobuf::uint32 value); + inline void add_role(::google::protobuf::uint32 value); + inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + role() const; + inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_role(); + + static const int kFriendInvitationFieldNumber = 103; + static ::google::protobuf::internal::ExtensionIdentifier< ::bgs::protocol::Invitation, + ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::friends::v1::FriendInvitation >, 11, false > + friend_invitation; + // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.FriendInvitation) + private: + inline void set_has_first_received(); + inline void clear_has_first_received(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > role_; + mutable int _role_cached_byte_size_; + bool first_received_; + friend void TC_SHARED_API protobuf_AddDesc_friends_5ftypes_2eproto(); + friend void protobuf_AssignDesc_friends_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_friends_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static FriendInvitation* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API FriendInvitationParams : public ::google::protobuf::Message { + public: + FriendInvitationParams(); + virtual ~FriendInvitationParams(); + + FriendInvitationParams(const FriendInvitationParams& from); + + inline FriendInvitationParams& operator=(const FriendInvitationParams& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const FriendInvitationParams& default_instance(); + + void Swap(FriendInvitationParams* other); + + // implements Message ---------------------------------------------- + + FriendInvitationParams* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const FriendInvitationParams& from); + void MergeFrom(const FriendInvitationParams& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string target_email = 1; + inline bool has_target_email() const; + inline void clear_target_email(); + static const int kTargetEmailFieldNumber = 1; + inline const ::std::string& target_email() const; + inline void set_target_email(const ::std::string& value); + inline void set_target_email(const char* value); + inline void set_target_email(const char* value, size_t size); + inline ::std::string* mutable_target_email(); + inline ::std::string* release_target_email(); + inline void set_allocated_target_email(::std::string* target_email); + + // optional string target_battle_tag = 2; + inline bool has_target_battle_tag() const; + inline void clear_target_battle_tag(); + static const int kTargetBattleTagFieldNumber = 2; + inline const ::std::string& target_battle_tag() const; + inline void set_target_battle_tag(const ::std::string& value); + inline void set_target_battle_tag(const char* value); + inline void set_target_battle_tag(const char* value, size_t size); + inline ::std::string* mutable_target_battle_tag(); + inline ::std::string* release_target_battle_tag(); + inline void set_allocated_target_battle_tag(::std::string* target_battle_tag); + + // optional string inviter_battle_tag = 3; + inline bool has_inviter_battle_tag() const; + inline void clear_inviter_battle_tag(); + static const int kInviterBattleTagFieldNumber = 3; + inline const ::std::string& inviter_battle_tag() const; + inline void set_inviter_battle_tag(const ::std::string& value); + inline void set_inviter_battle_tag(const char* value); + inline void set_inviter_battle_tag(const char* value, size_t size); + inline ::std::string* mutable_inviter_battle_tag(); + inline ::std::string* release_inviter_battle_tag(); + inline void set_allocated_inviter_battle_tag(::std::string* inviter_battle_tag); + + // optional string inviter_full_name = 4; + inline bool has_inviter_full_name() const; + inline void clear_inviter_full_name(); + static const int kInviterFullNameFieldNumber = 4; + inline const ::std::string& inviter_full_name() const; + inline void set_inviter_full_name(const ::std::string& value); + inline void set_inviter_full_name(const char* value); + inline void set_inviter_full_name(const char* value, size_t size); + inline ::std::string* mutable_inviter_full_name(); + inline ::std::string* release_inviter_full_name(); + inline void set_allocated_inviter_full_name(::std::string* inviter_full_name); + + // optional string invitee_display_name = 5; + inline bool has_invitee_display_name() const; + inline void clear_invitee_display_name(); + static const int kInviteeDisplayNameFieldNumber = 5; + inline const ::std::string& invitee_display_name() const; + inline void set_invitee_display_name(const ::std::string& value); + inline void set_invitee_display_name(const char* value); + inline void set_invitee_display_name(const char* value, size_t size); + inline ::std::string* mutable_invitee_display_name(); + inline ::std::string* release_invitee_display_name(); + inline void set_allocated_invitee_display_name(::std::string* invitee_display_name); + + // repeated uint32 role = 6 [packed = true]; + inline int role_size() const; + inline void clear_role(); + static const int kRoleFieldNumber = 6; + inline ::google::protobuf::uint32 role(int index) const; + inline void set_role(int index, ::google::protobuf::uint32 value); + inline void add_role(::google::protobuf::uint32 value); + inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + role() const; + inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_role(); + + // repeated uint32 previous_role_deprecated = 7 [packed = true, deprecated = true]; + inline int previous_role_deprecated_size() const PROTOBUF_DEPRECATED; + inline void clear_previous_role_deprecated() PROTOBUF_DEPRECATED; + static const int kPreviousRoleDeprecatedFieldNumber = 7; + inline ::google::protobuf::uint32 previous_role_deprecated(int index) const PROTOBUF_DEPRECATED; + inline void set_previous_role_deprecated(int index, ::google::protobuf::uint32 value) PROTOBUF_DEPRECATED; + inline void add_previous_role_deprecated(::google::protobuf::uint32 value) PROTOBUF_DEPRECATED; + inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + previous_role_deprecated() const PROTOBUF_DEPRECATED; + inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_previous_role_deprecated() PROTOBUF_DEPRECATED; + + static const int kFriendParamsFieldNumber = 103; + static ::google::protobuf::internal::ExtensionIdentifier< ::bgs::protocol::InvitationParams, + ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::friends::v1::FriendInvitationParams >, 11, false > + friend_params; + // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.FriendInvitationParams) + private: + inline void set_has_target_email(); + inline void clear_has_target_email(); + inline void set_has_target_battle_tag(); + inline void clear_has_target_battle_tag(); + inline void set_has_inviter_battle_tag(); + inline void clear_has_inviter_battle_tag(); + inline void set_has_inviter_full_name(); + inline void clear_has_inviter_full_name(); + inline void set_has_invitee_display_name(); + inline void clear_has_invitee_display_name(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* target_email_; + ::std::string* target_battle_tag_; + ::std::string* inviter_battle_tag_; + ::std::string* inviter_full_name_; + ::std::string* invitee_display_name_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > role_; + mutable int _role_cached_byte_size_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > previous_role_deprecated_; + mutable int _previous_role_deprecated_cached_byte_size_; + friend void TC_SHARED_API protobuf_AddDesc_friends_5ftypes_2eproto(); + friend void protobuf_AssignDesc_friends_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_friends_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static FriendInvitationParams* default_instance_; +}; +// =================================================================== + + +// =================================================================== + + +// =================================================================== + +// Friend + +// required .bgs.protocol.EntityId account_id = 1; +inline bool Friend::has_account_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Friend::set_has_account_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void Friend::clear_has_account_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Friend::clear_account_id() { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_account_id(); +} +inline const ::bgs::protocol::EntityId& Friend::account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.Friend.account_id) + return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_; +} +inline ::bgs::protocol::EntityId* Friend::mutable_account_id() { + set_has_account_id(); + if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.Friend.account_id) + return account_id_; +} +inline ::bgs::protocol::EntityId* Friend::release_account_id() { + clear_has_account_id(); + ::bgs::protocol::EntityId* temp = account_id_; + account_id_ = NULL; + return temp; +} +inline void Friend::set_allocated_account_id(::bgs::protocol::EntityId* account_id) { + delete account_id_; + account_id_ = account_id; + if (account_id) { + set_has_account_id(); + } else { + clear_has_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.Friend.account_id) +} + +// repeated .bgs.protocol.Attribute attribute = 2; +inline int Friend::attribute_size() const { + return attribute_.size(); +} +inline void Friend::clear_attribute() { + attribute_.Clear(); +} +inline const ::bgs::protocol::Attribute& Friend::attribute(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.Friend.attribute) + return attribute_.Get(index); +} +inline ::bgs::protocol::Attribute* Friend::mutable_attribute(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.Friend.attribute) + return attribute_.Mutable(index); +} +inline ::bgs::protocol::Attribute* Friend::add_attribute() { + // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.Friend.attribute) + return attribute_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& +Friend::attribute() const { + // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.Friend.attribute) + return attribute_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* +Friend::mutable_attribute() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.Friend.attribute) + return &attribute_; +} + +// repeated uint32 role = 3 [packed = true]; +inline int Friend::role_size() const { + return role_.size(); +} +inline void Friend::clear_role() { + role_.Clear(); +} +inline ::google::protobuf::uint32 Friend::role(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.Friend.role) + return role_.Get(index); +} +inline void Friend::set_role(int index, ::google::protobuf::uint32 value) { + role_.Set(index, value); + // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.Friend.role) +} +inline void Friend::add_role(::google::protobuf::uint32 value) { + role_.Add(value); + // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.Friend.role) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +Friend::role() const { + // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.Friend.role) + return role_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +Friend::mutable_role() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.Friend.role) + return &role_; +} + +// optional uint64 privileges = 4 [default = 0]; +inline bool Friend::has_privileges() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void Friend::set_has_privileges() { + _has_bits_[0] |= 0x00000008u; +} +inline void Friend::clear_has_privileges() { + _has_bits_[0] &= ~0x00000008u; +} +inline void Friend::clear_privileges() { + privileges_ = GOOGLE_ULONGLONG(0); + clear_has_privileges(); +} +inline ::google::protobuf::uint64 Friend::privileges() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.Friend.privileges) + return privileges_; +} +inline void Friend::set_privileges(::google::protobuf::uint64 value) { + set_has_privileges(); + privileges_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.Friend.privileges) +} + +// optional uint64 attributes_epoch = 5; +inline bool Friend::has_attributes_epoch() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void Friend::set_has_attributes_epoch() { + _has_bits_[0] |= 0x00000010u; +} +inline void Friend::clear_has_attributes_epoch() { + _has_bits_[0] &= ~0x00000010u; +} +inline void Friend::clear_attributes_epoch() { + attributes_epoch_ = GOOGLE_ULONGLONG(0); + clear_has_attributes_epoch(); +} +inline ::google::protobuf::uint64 Friend::attributes_epoch() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.Friend.attributes_epoch) + return attributes_epoch_; +} +inline void Friend::set_attributes_epoch(::google::protobuf::uint64 value) { + set_has_attributes_epoch(); + attributes_epoch_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.Friend.attributes_epoch) +} + +// optional string full_name = 6; +inline bool Friend::has_full_name() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void Friend::set_has_full_name() { + _has_bits_[0] |= 0x00000020u; +} +inline void Friend::clear_has_full_name() { + _has_bits_[0] &= ~0x00000020u; +} +inline void Friend::clear_full_name() { + if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + full_name_->clear(); + } + clear_has_full_name(); +} +inline const ::std::string& Friend::full_name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.Friend.full_name) + return *full_name_; +} +inline void Friend::set_full_name(const ::std::string& value) { + set_has_full_name(); + if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + full_name_ = new ::std::string; + } + full_name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.Friend.full_name) +} +inline void Friend::set_full_name(const char* value) { + set_has_full_name(); + if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + full_name_ = new ::std::string; + } + full_name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.friends.v1.Friend.full_name) +} +inline void Friend::set_full_name(const char* value, size_t size) { + set_has_full_name(); + if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + full_name_ = new ::std::string; + } + full_name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.friends.v1.Friend.full_name) +} +inline ::std::string* Friend::mutable_full_name() { + set_has_full_name(); + if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + full_name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.Friend.full_name) + return full_name_; +} +inline ::std::string* Friend::release_full_name() { + clear_has_full_name(); + if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = full_name_; + full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void Friend::set_allocated_full_name(::std::string* full_name) { + if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete full_name_; + } + if (full_name) { + set_has_full_name(); + full_name_ = full_name; + } else { + clear_has_full_name(); + full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.Friend.full_name) +} + +// optional string battle_tag = 7; +inline bool Friend::has_battle_tag() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void Friend::set_has_battle_tag() { + _has_bits_[0] |= 0x00000040u; +} +inline void Friend::clear_has_battle_tag() { + _has_bits_[0] &= ~0x00000040u; +} +inline void Friend::clear_battle_tag() { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_->clear(); + } + clear_has_battle_tag(); +} +inline const ::std::string& Friend::battle_tag() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.Friend.battle_tag) + return *battle_tag_; +} +inline void Friend::set_battle_tag(const ::std::string& value) { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + battle_tag_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.Friend.battle_tag) +} +inline void Friend::set_battle_tag(const char* value) { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + battle_tag_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.friends.v1.Friend.battle_tag) +} +inline void Friend::set_battle_tag(const char* value, size_t size) { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + battle_tag_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.friends.v1.Friend.battle_tag) +} +inline ::std::string* Friend::mutable_battle_tag() { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.Friend.battle_tag) + return battle_tag_; +} +inline ::std::string* Friend::release_battle_tag() { + clear_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = battle_tag_; + battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void Friend::set_allocated_battle_tag(::std::string* battle_tag) { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete battle_tag_; + } + if (battle_tag) { + set_has_battle_tag(); + battle_tag_ = battle_tag; + } else { + clear_has_battle_tag(); + battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.Friend.battle_tag) +} + +// ------------------------------------------------------------------- + +// FriendInvitation + +// optional bool first_received = 1 [default = false]; +inline bool FriendInvitation::has_first_received() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void FriendInvitation::set_has_first_received() { + _has_bits_[0] |= 0x00000001u; +} +inline void FriendInvitation::clear_has_first_received() { + _has_bits_[0] &= ~0x00000001u; +} +inline void FriendInvitation::clear_first_received() { + first_received_ = false; + clear_has_first_received(); +} +inline bool FriendInvitation::first_received() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitation.first_received) + return first_received_; +} +inline void FriendInvitation::set_first_received(bool value) { + set_has_first_received(); + first_received_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitation.first_received) +} + +// repeated uint32 role = 2 [packed = true]; +inline int FriendInvitation::role_size() const { + return role_.size(); +} +inline void FriendInvitation::clear_role() { + role_.Clear(); +} +inline ::google::protobuf::uint32 FriendInvitation::role(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitation.role) + return role_.Get(index); +} +inline void FriendInvitation::set_role(int index, ::google::protobuf::uint32 value) { + role_.Set(index, value); + // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitation.role) +} +inline void FriendInvitation::add_role(::google::protobuf::uint32 value) { + role_.Add(value); + // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.FriendInvitation.role) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +FriendInvitation::role() const { + // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.FriendInvitation.role) + return role_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +FriendInvitation::mutable_role() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.FriendInvitation.role) + return &role_; +} + +// ------------------------------------------------------------------- + +// FriendInvitationParams + +// optional string target_email = 1; +inline bool FriendInvitationParams::has_target_email() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void FriendInvitationParams::set_has_target_email() { + _has_bits_[0] |= 0x00000001u; +} +inline void FriendInvitationParams::clear_has_target_email() { + _has_bits_[0] &= ~0x00000001u; +} +inline void FriendInvitationParams::clear_target_email() { + if (target_email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + target_email_->clear(); + } + clear_has_target_email(); +} +inline const ::std::string& FriendInvitationParams::target_email() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitationParams.target_email) + return *target_email_; +} +inline void FriendInvitationParams::set_target_email(const ::std::string& value) { + set_has_target_email(); + if (target_email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + target_email_ = new ::std::string; + } + target_email_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitationParams.target_email) +} +inline void FriendInvitationParams::set_target_email(const char* value) { + set_has_target_email(); + if (target_email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + target_email_ = new ::std::string; + } + target_email_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.friends.v1.FriendInvitationParams.target_email) +} +inline void FriendInvitationParams::set_target_email(const char* value, size_t size) { + set_has_target_email(); + if (target_email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + target_email_ = new ::std::string; + } + target_email_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.friends.v1.FriendInvitationParams.target_email) +} +inline ::std::string* FriendInvitationParams::mutable_target_email() { + set_has_target_email(); + if (target_email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + target_email_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendInvitationParams.target_email) + return target_email_; +} +inline ::std::string* FriendInvitationParams::release_target_email() { + clear_has_target_email(); + if (target_email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = target_email_; + target_email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void FriendInvitationParams::set_allocated_target_email(::std::string* target_email) { + if (target_email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete target_email_; + } + if (target_email) { + set_has_target_email(); + target_email_ = target_email; + } else { + clear_has_target_email(); + target_email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendInvitationParams.target_email) +} + +// optional string target_battle_tag = 2; +inline bool FriendInvitationParams::has_target_battle_tag() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void FriendInvitationParams::set_has_target_battle_tag() { + _has_bits_[0] |= 0x00000002u; +} +inline void FriendInvitationParams::clear_has_target_battle_tag() { + _has_bits_[0] &= ~0x00000002u; +} +inline void FriendInvitationParams::clear_target_battle_tag() { + if (target_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + target_battle_tag_->clear(); + } + clear_has_target_battle_tag(); +} +inline const ::std::string& FriendInvitationParams::target_battle_tag() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitationParams.target_battle_tag) + return *target_battle_tag_; +} +inline void FriendInvitationParams::set_target_battle_tag(const ::std::string& value) { + set_has_target_battle_tag(); + if (target_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + target_battle_tag_ = new ::std::string; + } + target_battle_tag_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitationParams.target_battle_tag) +} +inline void FriendInvitationParams::set_target_battle_tag(const char* value) { + set_has_target_battle_tag(); + if (target_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + target_battle_tag_ = new ::std::string; + } + target_battle_tag_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.friends.v1.FriendInvitationParams.target_battle_tag) +} +inline void FriendInvitationParams::set_target_battle_tag(const char* value, size_t size) { + set_has_target_battle_tag(); + if (target_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + target_battle_tag_ = new ::std::string; + } + target_battle_tag_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.friends.v1.FriendInvitationParams.target_battle_tag) +} +inline ::std::string* FriendInvitationParams::mutable_target_battle_tag() { + set_has_target_battle_tag(); + if (target_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + target_battle_tag_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendInvitationParams.target_battle_tag) + return target_battle_tag_; +} +inline ::std::string* FriendInvitationParams::release_target_battle_tag() { + clear_has_target_battle_tag(); + if (target_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = target_battle_tag_; + target_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void FriendInvitationParams::set_allocated_target_battle_tag(::std::string* target_battle_tag) { + if (target_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete target_battle_tag_; + } + if (target_battle_tag) { + set_has_target_battle_tag(); + target_battle_tag_ = target_battle_tag; + } else { + clear_has_target_battle_tag(); + target_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendInvitationParams.target_battle_tag) +} + +// optional string inviter_battle_tag = 3; +inline bool FriendInvitationParams::has_inviter_battle_tag() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void FriendInvitationParams::set_has_inviter_battle_tag() { + _has_bits_[0] |= 0x00000004u; +} +inline void FriendInvitationParams::clear_has_inviter_battle_tag() { + _has_bits_[0] &= ~0x00000004u; +} +inline void FriendInvitationParams::clear_inviter_battle_tag() { + if (inviter_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + inviter_battle_tag_->clear(); + } + clear_has_inviter_battle_tag(); +} +inline const ::std::string& FriendInvitationParams::inviter_battle_tag() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitationParams.inviter_battle_tag) + return *inviter_battle_tag_; +} +inline void FriendInvitationParams::set_inviter_battle_tag(const ::std::string& value) { + set_has_inviter_battle_tag(); + if (inviter_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + inviter_battle_tag_ = new ::std::string; + } + inviter_battle_tag_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitationParams.inviter_battle_tag) +} +inline void FriendInvitationParams::set_inviter_battle_tag(const char* value) { + set_has_inviter_battle_tag(); + if (inviter_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + inviter_battle_tag_ = new ::std::string; + } + inviter_battle_tag_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.friends.v1.FriendInvitationParams.inviter_battle_tag) +} +inline void FriendInvitationParams::set_inviter_battle_tag(const char* value, size_t size) { + set_has_inviter_battle_tag(); + if (inviter_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + inviter_battle_tag_ = new ::std::string; + } + inviter_battle_tag_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.friends.v1.FriendInvitationParams.inviter_battle_tag) +} +inline ::std::string* FriendInvitationParams::mutable_inviter_battle_tag() { + set_has_inviter_battle_tag(); + if (inviter_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + inviter_battle_tag_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendInvitationParams.inviter_battle_tag) + return inviter_battle_tag_; +} +inline ::std::string* FriendInvitationParams::release_inviter_battle_tag() { + clear_has_inviter_battle_tag(); + if (inviter_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = inviter_battle_tag_; + inviter_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void FriendInvitationParams::set_allocated_inviter_battle_tag(::std::string* inviter_battle_tag) { + if (inviter_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete inviter_battle_tag_; + } + if (inviter_battle_tag) { + set_has_inviter_battle_tag(); + inviter_battle_tag_ = inviter_battle_tag; + } else { + clear_has_inviter_battle_tag(); + inviter_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendInvitationParams.inviter_battle_tag) +} + +// optional string inviter_full_name = 4; +inline bool FriendInvitationParams::has_inviter_full_name() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void FriendInvitationParams::set_has_inviter_full_name() { + _has_bits_[0] |= 0x00000008u; +} +inline void FriendInvitationParams::clear_has_inviter_full_name() { + _has_bits_[0] &= ~0x00000008u; +} +inline void FriendInvitationParams::clear_inviter_full_name() { + if (inviter_full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + inviter_full_name_->clear(); + } + clear_has_inviter_full_name(); +} +inline const ::std::string& FriendInvitationParams::inviter_full_name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitationParams.inviter_full_name) + return *inviter_full_name_; +} +inline void FriendInvitationParams::set_inviter_full_name(const ::std::string& value) { + set_has_inviter_full_name(); + if (inviter_full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + inviter_full_name_ = new ::std::string; + } + inviter_full_name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitationParams.inviter_full_name) +} +inline void FriendInvitationParams::set_inviter_full_name(const char* value) { + set_has_inviter_full_name(); + if (inviter_full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + inviter_full_name_ = new ::std::string; + } + inviter_full_name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.friends.v1.FriendInvitationParams.inviter_full_name) +} +inline void FriendInvitationParams::set_inviter_full_name(const char* value, size_t size) { + set_has_inviter_full_name(); + if (inviter_full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + inviter_full_name_ = new ::std::string; + } + inviter_full_name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.friends.v1.FriendInvitationParams.inviter_full_name) +} +inline ::std::string* FriendInvitationParams::mutable_inviter_full_name() { + set_has_inviter_full_name(); + if (inviter_full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + inviter_full_name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendInvitationParams.inviter_full_name) + return inviter_full_name_; +} +inline ::std::string* FriendInvitationParams::release_inviter_full_name() { + clear_has_inviter_full_name(); + if (inviter_full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = inviter_full_name_; + inviter_full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void FriendInvitationParams::set_allocated_inviter_full_name(::std::string* inviter_full_name) { + if (inviter_full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete inviter_full_name_; + } + if (inviter_full_name) { + set_has_inviter_full_name(); + inviter_full_name_ = inviter_full_name; + } else { + clear_has_inviter_full_name(); + inviter_full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendInvitationParams.inviter_full_name) +} + +// optional string invitee_display_name = 5; +inline bool FriendInvitationParams::has_invitee_display_name() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void FriendInvitationParams::set_has_invitee_display_name() { + _has_bits_[0] |= 0x00000010u; +} +inline void FriendInvitationParams::clear_has_invitee_display_name() { + _has_bits_[0] &= ~0x00000010u; +} +inline void FriendInvitationParams::clear_invitee_display_name() { + if (invitee_display_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitee_display_name_->clear(); + } + clear_has_invitee_display_name(); +} +inline const ::std::string& FriendInvitationParams::invitee_display_name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitationParams.invitee_display_name) + return *invitee_display_name_; +} +inline void FriendInvitationParams::set_invitee_display_name(const ::std::string& value) { + set_has_invitee_display_name(); + if (invitee_display_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitee_display_name_ = new ::std::string; + } + invitee_display_name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitationParams.invitee_display_name) +} +inline void FriendInvitationParams::set_invitee_display_name(const char* value) { + set_has_invitee_display_name(); + if (invitee_display_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitee_display_name_ = new ::std::string; + } + invitee_display_name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.friends.v1.FriendInvitationParams.invitee_display_name) +} +inline void FriendInvitationParams::set_invitee_display_name(const char* value, size_t size) { + set_has_invitee_display_name(); + if (invitee_display_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitee_display_name_ = new ::std::string; + } + invitee_display_name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.friends.v1.FriendInvitationParams.invitee_display_name) +} +inline ::std::string* FriendInvitationParams::mutable_invitee_display_name() { + set_has_invitee_display_name(); + if (invitee_display_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitee_display_name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendInvitationParams.invitee_display_name) + return invitee_display_name_; +} +inline ::std::string* FriendInvitationParams::release_invitee_display_name() { + clear_has_invitee_display_name(); + if (invitee_display_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = invitee_display_name_; + invitee_display_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void FriendInvitationParams::set_allocated_invitee_display_name(::std::string* invitee_display_name) { + if (invitee_display_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete invitee_display_name_; + } + if (invitee_display_name) { + set_has_invitee_display_name(); + invitee_display_name_ = invitee_display_name; + } else { + clear_has_invitee_display_name(); + invitee_display_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendInvitationParams.invitee_display_name) +} + +// repeated uint32 role = 6 [packed = true]; +inline int FriendInvitationParams::role_size() const { + return role_.size(); +} +inline void FriendInvitationParams::clear_role() { + role_.Clear(); +} +inline ::google::protobuf::uint32 FriendInvitationParams::role(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitationParams.role) + return role_.Get(index); +} +inline void FriendInvitationParams::set_role(int index, ::google::protobuf::uint32 value) { + role_.Set(index, value); + // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitationParams.role) +} +inline void FriendInvitationParams::add_role(::google::protobuf::uint32 value) { + role_.Add(value); + // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.FriendInvitationParams.role) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +FriendInvitationParams::role() const { + // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.FriendInvitationParams.role) + return role_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +FriendInvitationParams::mutable_role() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.FriendInvitationParams.role) + return &role_; +} + +// repeated uint32 previous_role_deprecated = 7 [packed = true, deprecated = true]; +inline int FriendInvitationParams::previous_role_deprecated_size() const { + return previous_role_deprecated_.size(); +} +inline void FriendInvitationParams::clear_previous_role_deprecated() { + previous_role_deprecated_.Clear(); +} +inline ::google::protobuf::uint32 FriendInvitationParams::previous_role_deprecated(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitationParams.previous_role_deprecated) + return previous_role_deprecated_.Get(index); +} +inline void FriendInvitationParams::set_previous_role_deprecated(int index, ::google::protobuf::uint32 value) { + previous_role_deprecated_.Set(index, value); + // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitationParams.previous_role_deprecated) +} +inline void FriendInvitationParams::add_previous_role_deprecated(::google::protobuf::uint32 value) { + previous_role_deprecated_.Add(value); + // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.FriendInvitationParams.previous_role_deprecated) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +FriendInvitationParams::previous_role_deprecated() const { + // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.FriendInvitationParams.previous_role_deprecated) + return previous_role_deprecated_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +FriendInvitationParams::mutable_previous_role_deprecated() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.FriendInvitationParams.previous_role_deprecated) + return &previous_role_deprecated_; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace friends +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_friends_5ftypes_2eproto__INCLUDED diff --git a/src/server/proto/Client/game_utilities_service.pb.cc b/src/server/proto/Client/game_utilities_service.pb.cc new file mode 100644 index 00000000000..13188964cb4 --- /dev/null +++ b/src/server/proto/Client/game_utilities_service.pb.cc @@ -0,0 +1,4528 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: game_utilities_service.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "game_utilities_service.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +#include "BattlenetRpcErrorCodes.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { +namespace game_utilities { +namespace v1 { + +namespace { + +const ::google::protobuf::Descriptor* ClientRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ClientRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* ClientResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ClientResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* ServerRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ServerRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* ServerResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ServerResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* PresenceChannelCreatedRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + PresenceChannelCreatedRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* GetPlayerVariablesRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GetPlayerVariablesRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* GetPlayerVariablesResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GetPlayerVariablesResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* GameAccountOnlineNotification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GameAccountOnlineNotification_reflection_ = NULL; +const ::google::protobuf::Descriptor* GameAccountOfflineNotification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GameAccountOfflineNotification_reflection_ = NULL; +const ::google::protobuf::Descriptor* GetAchievementsFileRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GetAchievementsFileRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* GetAchievementsFileResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GetAchievementsFileResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* GetAllValuesForAttributeRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GetAllValuesForAttributeRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* GetAllValuesForAttributeResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GetAllValuesForAttributeResponse_reflection_ = NULL; +const ::google::protobuf::ServiceDescriptor* GameUtilitiesService_descriptor_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_game_5futilities_5fservice_2eproto() { + protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "game_utilities_service.proto"); + GOOGLE_CHECK(file != NULL); + ClientRequest_descriptor_ = file->message_type(0); + static const int ClientRequest_offsets_[6] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientRequest, attribute_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientRequest, host_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientRequest, account_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientRequest, game_account_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientRequest, program_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientRequest, client_info_), + }; + ClientRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ClientRequest_descriptor_, + ClientRequest::default_instance_, + ClientRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ClientRequest)); + ClientResponse_descriptor_ = file->message_type(1); + static const int ClientResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientResponse, attribute_), + }; + ClientResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ClientResponse_descriptor_, + ClientResponse::default_instance_, + ClientResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ClientResponse)); + ServerRequest_descriptor_ = file->message_type(2); + static const int ServerRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerRequest, attribute_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerRequest, program_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerRequest, host_), + }; + ServerRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ServerRequest_descriptor_, + ServerRequest::default_instance_, + ServerRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ServerRequest)); + ServerResponse_descriptor_ = file->message_type(3); + static const int ServerResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerResponse, attribute_), + }; + ServerResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ServerResponse_descriptor_, + ServerResponse::default_instance_, + ServerResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ServerResponse)); + PresenceChannelCreatedRequest_descriptor_ = file->message_type(4); + static const int PresenceChannelCreatedRequest_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PresenceChannelCreatedRequest, id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PresenceChannelCreatedRequest, game_account_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PresenceChannelCreatedRequest, account_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PresenceChannelCreatedRequest, host_), + }; + PresenceChannelCreatedRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + PresenceChannelCreatedRequest_descriptor_, + PresenceChannelCreatedRequest::default_instance_, + PresenceChannelCreatedRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PresenceChannelCreatedRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PresenceChannelCreatedRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(PresenceChannelCreatedRequest)); + GetPlayerVariablesRequest_descriptor_ = file->message_type(5); + static const int GetPlayerVariablesRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetPlayerVariablesRequest, player_variables_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetPlayerVariablesRequest, host_), + }; + GetPlayerVariablesRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GetPlayerVariablesRequest_descriptor_, + GetPlayerVariablesRequest::default_instance_, + GetPlayerVariablesRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetPlayerVariablesRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetPlayerVariablesRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GetPlayerVariablesRequest)); + GetPlayerVariablesResponse_descriptor_ = file->message_type(6); + static const int GetPlayerVariablesResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetPlayerVariablesResponse, player_variables_), + }; + GetPlayerVariablesResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GetPlayerVariablesResponse_descriptor_, + GetPlayerVariablesResponse::default_instance_, + GetPlayerVariablesResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetPlayerVariablesResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetPlayerVariablesResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GetPlayerVariablesResponse)); + GameAccountOnlineNotification_descriptor_ = file->message_type(7); + static const int GameAccountOnlineNotification_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountOnlineNotification, game_account_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountOnlineNotification, host_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountOnlineNotification, session_id_), + }; + GameAccountOnlineNotification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GameAccountOnlineNotification_descriptor_, + GameAccountOnlineNotification::default_instance_, + GameAccountOnlineNotification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountOnlineNotification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountOnlineNotification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GameAccountOnlineNotification)); + GameAccountOfflineNotification_descriptor_ = file->message_type(8); + static const int GameAccountOfflineNotification_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountOfflineNotification, game_account_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountOfflineNotification, host_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountOfflineNotification, session_id_), + }; + GameAccountOfflineNotification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GameAccountOfflineNotification_descriptor_, + GameAccountOfflineNotification::default_instance_, + GameAccountOfflineNotification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountOfflineNotification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountOfflineNotification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GameAccountOfflineNotification)); + GetAchievementsFileRequest_descriptor_ = file->message_type(9); + static const int GetAchievementsFileRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAchievementsFileRequest, host_), + }; + GetAchievementsFileRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GetAchievementsFileRequest_descriptor_, + GetAchievementsFileRequest::default_instance_, + GetAchievementsFileRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAchievementsFileRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAchievementsFileRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GetAchievementsFileRequest)); + GetAchievementsFileResponse_descriptor_ = file->message_type(10); + static const int GetAchievementsFileResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAchievementsFileResponse, content_handle_), + }; + GetAchievementsFileResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GetAchievementsFileResponse_descriptor_, + GetAchievementsFileResponse::default_instance_, + GetAchievementsFileResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAchievementsFileResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAchievementsFileResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GetAchievementsFileResponse)); + GetAllValuesForAttributeRequest_descriptor_ = file->message_type(11); + static const int GetAllValuesForAttributeRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAllValuesForAttributeRequest, attribute_key_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAllValuesForAttributeRequest, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAllValuesForAttributeRequest, program_), + }; + GetAllValuesForAttributeRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GetAllValuesForAttributeRequest_descriptor_, + GetAllValuesForAttributeRequest::default_instance_, + GetAllValuesForAttributeRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAllValuesForAttributeRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAllValuesForAttributeRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GetAllValuesForAttributeRequest)); + GetAllValuesForAttributeResponse_descriptor_ = file->message_type(12); + static const int GetAllValuesForAttributeResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAllValuesForAttributeResponse, attribute_value_), + }; + GetAllValuesForAttributeResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GetAllValuesForAttributeResponse_descriptor_, + GetAllValuesForAttributeResponse::default_instance_, + GetAllValuesForAttributeResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAllValuesForAttributeResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAllValuesForAttributeResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GetAllValuesForAttributeResponse)); + GameUtilitiesService_descriptor_ = file->service(0); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_game_5futilities_5fservice_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ClientRequest_descriptor_, &ClientRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ClientResponse_descriptor_, &ClientResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ServerRequest_descriptor_, &ServerRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ServerResponse_descriptor_, &ServerResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + PresenceChannelCreatedRequest_descriptor_, &PresenceChannelCreatedRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GetPlayerVariablesRequest_descriptor_, &GetPlayerVariablesRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GetPlayerVariablesResponse_descriptor_, &GetPlayerVariablesResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GameAccountOnlineNotification_descriptor_, &GameAccountOnlineNotification::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GameAccountOfflineNotification_descriptor_, &GameAccountOfflineNotification::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GetAchievementsFileRequest_descriptor_, &GetAchievementsFileRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GetAchievementsFileResponse_descriptor_, &GetAchievementsFileResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GetAllValuesForAttributeRequest_descriptor_, &GetAllValuesForAttributeRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GetAllValuesForAttributeResponse_descriptor_, &GetAllValuesForAttributeResponse::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto() { + delete ClientRequest::default_instance_; + delete ClientRequest_reflection_; + delete ClientResponse::default_instance_; + delete ClientResponse_reflection_; + delete ServerRequest::default_instance_; + delete ServerRequest_reflection_; + delete ServerResponse::default_instance_; + delete ServerResponse_reflection_; + delete PresenceChannelCreatedRequest::default_instance_; + delete PresenceChannelCreatedRequest_reflection_; + delete GetPlayerVariablesRequest::default_instance_; + delete GetPlayerVariablesRequest_reflection_; + delete GetPlayerVariablesResponse::default_instance_; + delete GetPlayerVariablesResponse_reflection_; + delete GameAccountOnlineNotification::default_instance_; + delete GameAccountOnlineNotification_reflection_; + delete GameAccountOfflineNotification::default_instance_; + delete GameAccountOfflineNotification_reflection_; + delete GetAchievementsFileRequest::default_instance_; + delete GetAchievementsFileRequest_reflection_; + delete GetAchievementsFileResponse::default_instance_; + delete GetAchievementsFileResponse_reflection_; + delete GetAllValuesForAttributeRequest::default_instance_; + delete GetAllValuesForAttributeRequest_reflection_; + delete GetAllValuesForAttributeResponse::default_instance_; + delete GetAllValuesForAttributeResponse_reflection_; +} + +void protobuf_AddDesc_game_5futilities_5fservice_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_content_5fhandle_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto(); + ::bgs::protocol::game_utilities::v1::protobuf_AddDesc_game_5futilities_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\034game_utilities_service.proto\022\036bgs.prot" + "ocol.game_utilities.v1\032\025attribute_types." + "proto\032\032content_handle_types.proto\032\022entit" + "y_types.proto\032\032game_utilities_types.prot" + "o\032\017rpc_types.proto\"\221\002\n\rClientRequest\022*\n\t" + "attribute\030\001 \003(\0132\027.bgs.protocol.Attribute" + "\022%\n\004host\030\002 \001(\0132\027.bgs.protocol.ProcessId\022" + "*\n\naccount_id\030\003 \001(\0132\026.bgs.protocol.Entit" + "yId\022/\n\017game_account_id\030\004 \001(\0132\026.bgs.proto" + "col.EntityId\022\017\n\007program\030\005 \001(\007\022\?\n\013client_" + "info\030\006 \001(\0132*.bgs.protocol.game_utilities" + ".v1.ClientInfo\"<\n\016ClientResponse\022*\n\tattr" + "ibute\030\001 \003(\0132\027.bgs.protocol.Attribute\"s\n\r" + "ServerRequest\022*\n\tattribute\030\001 \003(\0132\027.bgs.p" + "rotocol.Attribute\022\017\n\007program\030\002 \002(\007\022%\n\004ho" + "st\030\003 \001(\0132\027.bgs.protocol.ProcessId\"<\n\016Ser" + "verResponse\022*\n\tattribute\030\001 \003(\0132\027.bgs.pro" + "tocol.Attribute\"\307\001\n\035PresenceChannelCreat" + "edRequest\022\"\n\002id\030\001 \002(\0132\026.bgs.protocol.Ent" + "ityId\022/\n\017game_account_id\030\003 \001(\0132\026.bgs.pro" + "tocol.EntityId\022*\n\naccount_id\030\004 \001(\0132\026.bgs" + ".protocol.EntityId\022%\n\004host\030\005 \001(\0132\027.bgs.p" + "rotocol.ProcessId\"\215\001\n\031GetPlayerVariables" + "Request\022I\n\020player_variables\030\001 \003(\0132/.bgs." + "protocol.game_utilities.v1.PlayerVariabl" + "es\022%\n\004host\030\002 \001(\0132\027.bgs.protocol.ProcessI" + "d\"g\n\032GetPlayerVariablesResponse\022I\n\020playe" + "r_variables\030\001 \003(\0132/.bgs.protocol.game_ut" + "ilities.v1.PlayerVariables\"\213\001\n\035GameAccou" + "ntOnlineNotification\022/\n\017game_account_id\030" + "\001 \002(\0132\026.bgs.protocol.EntityId\022%\n\004host\030\002 " + "\001(\0132\027.bgs.protocol.ProcessId\022\022\n\nsession_" + "id\030\003 \001(\t\"\214\001\n\036GameAccountOfflineNotificat" + "ion\022/\n\017game_account_id\030\001 \002(\0132\026.bgs.proto" + "col.EntityId\022%\n\004host\030\002 \001(\0132\027.bgs.protoco" + "l.ProcessId\022\022\n\nsession_id\030\003 \001(\t\"C\n\032GetAc" + "hievementsFileRequest\022%\n\004host\030\001 \001(\0132\027.bg" + "s.protocol.ProcessId\"R\n\033GetAchievementsF" + "ileResponse\0223\n\016content_handle\030\001 \001(\0132\033.bg" + "s.protocol.ContentHandle\"s\n\037GetAllValues" + "ForAttributeRequest\022\025\n\rattribute_key\030\001 \001" + "(\t\022(\n\010agent_id\030\002 \001(\0132\026.bgs.protocol.Enti" + "tyId\022\017\n\007program\030\005 \001(\007\"R\n GetAllValuesFor" + "AttributeResponse\022.\n\017attribute_value\030\001 \003" + "(\0132\025.bgs.protocol.Variant2\365\010\n\024GameUtilit" + "iesService\022{\n\024ProcessClientRequest\022-.bgs" + ".protocol.game_utilities.v1.ClientReques" + "t\032..bgs.protocol.game_utilities.v1.Clien" + "tResponse\"\004\200\265\030\001\022s\n\026PresenceChannelCreate" + "d\022=.bgs.protocol.game_utilities.v1.Prese" + "nceChannelCreatedRequest\032\024.bgs.protocol." + "NoData\"\004\200\265\030\002\022\221\001\n\022GetPlayerVariables\0229.bg" + "s.protocol.game_utilities.v1.GetPlayerVa" + "riablesRequest\032:.bgs.protocol.game_utili" + "ties.v1.GetPlayerVariablesResponse\"\004\200\265\030\003" + "\022{\n\024ProcessServerRequest\022-.bgs.protocol." + "game_utilities.v1.ServerRequest\032..bgs.pr" + "otocol.game_utilities.v1.ServerResponse\"" + "\004\200\265\030\006\022u\n\023OnGameAccountOnline\022=.bgs.proto" + "col.game_utilities.v1.GameAccountOnlineN" + "otification\032\031.bgs.protocol.NO_RESPONSE\"\004" + "\200\265\030\007\022w\n\024OnGameAccountOffline\022>.bgs.proto" + "col.game_utilities.v1.GameAccountOffline" + "Notification\032\031.bgs.protocol.NO_RESPONSE\"" + "\004\200\265\030\010\022\224\001\n\023GetAchievementsFile\022:.bgs.prot" + "ocol.game_utilities.v1.GetAchievementsFi" + "leRequest\032;.bgs.protocol.game_utilities." + "v1.GetAchievementsFileResponse\"\004\200\265\030\t\022\243\001\n" + "\030GetAllValuesForAttribute\022\?.bgs.protocol" + ".game_utilities.v1.GetAllValuesForAttrib" + "uteRequest\032@.bgs.protocol.game_utilities" + ".v1.GetAllValuesForAttributeResponse\"\004\200\265" + "\030\n\032-\312>*bnet.protocol.game_utilities.Game" + "UtilitiesBD\n\037bnet.protocol.game_utilitie" + "s.v1B\031GameUtilitiesServiceProtoH\001\200\001\000\210\001\001", 2999); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "game_utilities_service.proto", &protobuf_RegisterTypes); + ClientRequest::default_instance_ = new ClientRequest(); + ClientResponse::default_instance_ = new ClientResponse(); + ServerRequest::default_instance_ = new ServerRequest(); + ServerResponse::default_instance_ = new ServerResponse(); + PresenceChannelCreatedRequest::default_instance_ = new PresenceChannelCreatedRequest(); + GetPlayerVariablesRequest::default_instance_ = new GetPlayerVariablesRequest(); + GetPlayerVariablesResponse::default_instance_ = new GetPlayerVariablesResponse(); + GameAccountOnlineNotification::default_instance_ = new GameAccountOnlineNotification(); + GameAccountOfflineNotification::default_instance_ = new GameAccountOfflineNotification(); + GetAchievementsFileRequest::default_instance_ = new GetAchievementsFileRequest(); + GetAchievementsFileResponse::default_instance_ = new GetAchievementsFileResponse(); + GetAllValuesForAttributeRequest::default_instance_ = new GetAllValuesForAttributeRequest(); + GetAllValuesForAttributeResponse::default_instance_ = new GetAllValuesForAttributeResponse(); + ClientRequest::default_instance_->InitAsDefaultInstance(); + ClientResponse::default_instance_->InitAsDefaultInstance(); + ServerRequest::default_instance_->InitAsDefaultInstance(); + ServerResponse::default_instance_->InitAsDefaultInstance(); + PresenceChannelCreatedRequest::default_instance_->InitAsDefaultInstance(); + GetPlayerVariablesRequest::default_instance_->InitAsDefaultInstance(); + GetPlayerVariablesResponse::default_instance_->InitAsDefaultInstance(); + GameAccountOnlineNotification::default_instance_->InitAsDefaultInstance(); + GameAccountOfflineNotification::default_instance_->InitAsDefaultInstance(); + GetAchievementsFileRequest::default_instance_->InitAsDefaultInstance(); + GetAchievementsFileResponse::default_instance_->InitAsDefaultInstance(); + GetAllValuesForAttributeRequest::default_instance_->InitAsDefaultInstance(); + GetAllValuesForAttributeResponse::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_game_5futilities_5fservice_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_game_5futilities_5fservice_2eproto { + StaticDescriptorInitializer_game_5futilities_5fservice_2eproto() { + protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + } +} static_descriptor_initializer_game_5futilities_5fservice_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int ClientRequest::kAttributeFieldNumber; +const int ClientRequest::kHostFieldNumber; +const int ClientRequest::kAccountIdFieldNumber; +const int ClientRequest::kGameAccountIdFieldNumber; +const int ClientRequest::kProgramFieldNumber; +const int ClientRequest::kClientInfoFieldNumber; +#endif // !_MSC_VER + +ClientRequest::ClientRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.ClientRequest) +} + +void ClientRequest::InitAsDefaultInstance() { + host_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance()); + account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + client_info_ = const_cast< ::bgs::protocol::game_utilities::v1::ClientInfo*>(&::bgs::protocol::game_utilities::v1::ClientInfo::default_instance()); +} + +ClientRequest::ClientRequest(const ClientRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.ClientRequest) +} + +void ClientRequest::SharedCtor() { + _cached_size_ = 0; + host_ = NULL; + account_id_ = NULL; + game_account_id_ = NULL; + program_ = 0u; + client_info_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ClientRequest::~ClientRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.ClientRequest) + SharedDtor(); +} + +void ClientRequest::SharedDtor() { + if (this != default_instance_) { + delete host_; + delete account_id_; + delete game_account_id_; + delete client_info_; + } +} + +void ClientRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ClientRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ClientRequest_descriptor_; +} + +const ClientRequest& ClientRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + return *default_instance_; +} + +ClientRequest* ClientRequest::default_instance_ = NULL; + +ClientRequest* ClientRequest::New() const { + return new ClientRequest; +} + +void ClientRequest::Clear() { + if (_has_bits_[0 / 32] & 62) { + if (has_host()) { + if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear(); + } + if (has_account_id()) { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_game_account_id()) { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + } + program_ = 0u; + if (has_client_info()) { + if (client_info_ != NULL) client_info_->::bgs::protocol::game_utilities::v1::ClientInfo::Clear(); + } + } + attribute_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ClientRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.ClientRequest) + 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 .bgs.protocol.Attribute attribute = 1; + case 1: { + if (tag == 10) { + parse_attribute: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_attribute())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_attribute; + if (input->ExpectTag(18)) goto parse_host; + break; + } + + // optional .bgs.protocol.ProcessId host = 2; + case 2: { + if (tag == 18) { + parse_host: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_host())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_account_id; + break; + } + + // optional .bgs.protocol.EntityId account_id = 3; + case 3: { + if (tag == 26) { + parse_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_game_account_id; + break; + } + + // optional .bgs.protocol.EntityId game_account_id = 4; + case 4: { + if (tag == 34) { + parse_game_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(45)) goto parse_program; + break; + } + + // optional fixed32 program = 5; + case 5: { + if (tag == 45) { + parse_program: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &program_))); + set_has_program(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_client_info; + break; + } + + // optional .bgs.protocol.game_utilities.v1.ClientInfo client_info = 6; + case 6: { + if (tag == 50) { + parse_client_info: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_client_info())); + } 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:bgs.protocol.game_utilities.v1.ClientRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.ClientRequest) + return false; +#undef DO_ +} + +void ClientRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.ClientRequest) + // repeated .bgs.protocol.Attribute attribute = 1; + for (int i = 0; i < this->attribute_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->attribute(i), output); + } + + // optional .bgs.protocol.ProcessId host = 2; + if (has_host()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->host(), output); + } + + // optional .bgs.protocol.EntityId account_id = 3; + if (has_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->account_id(), output); + } + + // optional .bgs.protocol.EntityId game_account_id = 4; + if (has_game_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->game_account_id(), output); + } + + // optional fixed32 program = 5; + if (has_program()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->program(), output); + } + + // optional .bgs.protocol.game_utilities.v1.ClientInfo client_info = 6; + if (has_client_info()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, this->client_info(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.ClientRequest) +} + +::google::protobuf::uint8* ClientRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.ClientRequest) + // repeated .bgs.protocol.Attribute attribute = 1; + for (int i = 0; i < this->attribute_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->attribute(i), target); + } + + // optional .bgs.protocol.ProcessId host = 2; + if (has_host()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->host(), target); + } + + // optional .bgs.protocol.EntityId account_id = 3; + if (has_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->account_id(), target); + } + + // optional .bgs.protocol.EntityId game_account_id = 4; + if (has_game_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->game_account_id(), target); + } + + // optional fixed32 program = 5; + if (has_program()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->program(), target); + } + + // optional .bgs.protocol.game_utilities.v1.ClientInfo client_info = 6; + if (has_client_info()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 6, this->client_info(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.ClientRequest) + return target; +} + +int ClientRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) { + // optional .bgs.protocol.ProcessId host = 2; + if (has_host()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->host()); + } + + // optional .bgs.protocol.EntityId account_id = 3; + if (has_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account_id()); + } + + // optional .bgs.protocol.EntityId game_account_id = 4; + if (has_game_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account_id()); + } + + // optional fixed32 program = 5; + if (has_program()) { + total_size += 1 + 4; + } + + // optional .bgs.protocol.game_utilities.v1.ClientInfo client_info = 6; + if (has_client_info()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->client_info()); + } + + } + // repeated .bgs.protocol.Attribute attribute = 1; + total_size += 1 * this->attribute_size(); + for (int i = 0; i < this->attribute_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->attribute(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 ClientRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ClientRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ClientRequest::MergeFrom(const ClientRequest& from) { + GOOGLE_CHECK_NE(&from, this); + attribute_.MergeFrom(from.attribute_); + if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) { + if (from.has_host()) { + mutable_host()->::bgs::protocol::ProcessId::MergeFrom(from.host()); + } + if (from.has_account_id()) { + mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id()); + } + if (from.has_game_account_id()) { + mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id()); + } + if (from.has_program()) { + set_program(from.program()); + } + if (from.has_client_info()) { + mutable_client_info()->::bgs::protocol::game_utilities::v1::ClientInfo::MergeFrom(from.client_info()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ClientRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ClientRequest::CopyFrom(const ClientRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ClientRequest::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false; + if (has_host()) { + if (!this->host().IsInitialized()) return false; + } + if (has_account_id()) { + if (!this->account_id().IsInitialized()) return false; + } + if (has_game_account_id()) { + if (!this->game_account_id().IsInitialized()) return false; + } + return true; +} + +void ClientRequest::Swap(ClientRequest* other) { + if (other != this) { + attribute_.Swap(&other->attribute_); + std::swap(host_, other->host_); + std::swap(account_id_, other->account_id_); + std::swap(game_account_id_, other->game_account_id_); + std::swap(program_, other->program_); + std::swap(client_info_, other->client_info_); + 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 ClientRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ClientRequest_descriptor_; + metadata.reflection = ClientRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ClientResponse::kAttributeFieldNumber; +#endif // !_MSC_VER + +ClientResponse::ClientResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.ClientResponse) +} + +void ClientResponse::InitAsDefaultInstance() { +} + +ClientResponse::ClientResponse(const ClientResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.ClientResponse) +} + +void ClientResponse::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ClientResponse::~ClientResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.ClientResponse) + SharedDtor(); +} + +void ClientResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void ClientResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ClientResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ClientResponse_descriptor_; +} + +const ClientResponse& ClientResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + return *default_instance_; +} + +ClientResponse* ClientResponse::default_instance_ = NULL; + +ClientResponse* ClientResponse::New() const { + return new ClientResponse; +} + +void ClientResponse::Clear() { + attribute_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ClientResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.ClientResponse) + 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 .bgs.protocol.Attribute attribute = 1; + case 1: { + if (tag == 10) { + parse_attribute: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_attribute())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_attribute; + 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:bgs.protocol.game_utilities.v1.ClientResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.ClientResponse) + return false; +#undef DO_ +} + +void ClientResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.ClientResponse) + // repeated .bgs.protocol.Attribute attribute = 1; + for (int i = 0; i < this->attribute_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->attribute(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.ClientResponse) +} + +::google::protobuf::uint8* ClientResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.ClientResponse) + // repeated .bgs.protocol.Attribute attribute = 1; + for (int i = 0; i < this->attribute_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->attribute(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.ClientResponse) + return target; +} + +int ClientResponse::ByteSize() const { + int total_size = 0; + + // repeated .bgs.protocol.Attribute attribute = 1; + total_size += 1 * this->attribute_size(); + for (int i = 0; i < this->attribute_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->attribute(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 ClientResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ClientResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ClientResponse::MergeFrom(const ClientResponse& from) { + GOOGLE_CHECK_NE(&from, this); + attribute_.MergeFrom(from.attribute_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ClientResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ClientResponse::CopyFrom(const ClientResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ClientResponse::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false; + return true; +} + +void ClientResponse::Swap(ClientResponse* other) { + if (other != this) { + attribute_.Swap(&other->attribute_); + 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 ClientResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ClientResponse_descriptor_; + metadata.reflection = ClientResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ServerRequest::kAttributeFieldNumber; +const int ServerRequest::kProgramFieldNumber; +const int ServerRequest::kHostFieldNumber; +#endif // !_MSC_VER + +ServerRequest::ServerRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.ServerRequest) +} + +void ServerRequest::InitAsDefaultInstance() { + host_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance()); +} + +ServerRequest::ServerRequest(const ServerRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.ServerRequest) +} + +void ServerRequest::SharedCtor() { + _cached_size_ = 0; + program_ = 0u; + host_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ServerRequest::~ServerRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.ServerRequest) + SharedDtor(); +} + +void ServerRequest::SharedDtor() { + if (this != default_instance_) { + delete host_; + } +} + +void ServerRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ServerRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ServerRequest_descriptor_; +} + +const ServerRequest& ServerRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + return *default_instance_; +} + +ServerRequest* ServerRequest::default_instance_ = NULL; + +ServerRequest* ServerRequest::New() const { + return new ServerRequest; +} + +void ServerRequest::Clear() { + if (_has_bits_[0 / 32] & 6) { + program_ = 0u; + if (has_host()) { + if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear(); + } + } + attribute_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ServerRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.ServerRequest) + 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 .bgs.protocol.Attribute attribute = 1; + case 1: { + if (tag == 10) { + parse_attribute: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_attribute())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_attribute; + if (input->ExpectTag(21)) goto parse_program; + break; + } + + // required fixed32 program = 2; + case 2: { + if (tag == 21) { + parse_program: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &program_))); + set_has_program(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_host; + break; + } + + // optional .bgs.protocol.ProcessId host = 3; + case 3: { + if (tag == 26) { + parse_host: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_host())); + } 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:bgs.protocol.game_utilities.v1.ServerRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.ServerRequest) + return false; +#undef DO_ +} + +void ServerRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.ServerRequest) + // repeated .bgs.protocol.Attribute attribute = 1; + for (int i = 0; i < this->attribute_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->attribute(i), output); + } + + // required fixed32 program = 2; + if (has_program()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->program(), output); + } + + // optional .bgs.protocol.ProcessId host = 3; + if (has_host()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->host(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.ServerRequest) +} + +::google::protobuf::uint8* ServerRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.ServerRequest) + // repeated .bgs.protocol.Attribute attribute = 1; + for (int i = 0; i < this->attribute_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->attribute(i), target); + } + + // required fixed32 program = 2; + if (has_program()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->program(), target); + } + + // optional .bgs.protocol.ProcessId host = 3; + if (has_host()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->host(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.ServerRequest) + return target; +} + +int ServerRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) { + // required fixed32 program = 2; + if (has_program()) { + total_size += 1 + 4; + } + + // optional .bgs.protocol.ProcessId host = 3; + if (has_host()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->host()); + } + + } + // repeated .bgs.protocol.Attribute attribute = 1; + total_size += 1 * this->attribute_size(); + for (int i = 0; i < this->attribute_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->attribute(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 ServerRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ServerRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ServerRequest::MergeFrom(const ServerRequest& from) { + GOOGLE_CHECK_NE(&from, this); + attribute_.MergeFrom(from.attribute_); + if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) { + if (from.has_program()) { + set_program(from.program()); + } + if (from.has_host()) { + mutable_host()->::bgs::protocol::ProcessId::MergeFrom(from.host()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ServerRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ServerRequest::CopyFrom(const ServerRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ServerRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false; + + if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false; + if (has_host()) { + if (!this->host().IsInitialized()) return false; + } + return true; +} + +void ServerRequest::Swap(ServerRequest* other) { + if (other != this) { + attribute_.Swap(&other->attribute_); + std::swap(program_, other->program_); + std::swap(host_, other->host_); + 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 ServerRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ServerRequest_descriptor_; + metadata.reflection = ServerRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ServerResponse::kAttributeFieldNumber; +#endif // !_MSC_VER + +ServerResponse::ServerResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.ServerResponse) +} + +void ServerResponse::InitAsDefaultInstance() { +} + +ServerResponse::ServerResponse(const ServerResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.ServerResponse) +} + +void ServerResponse::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ServerResponse::~ServerResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.ServerResponse) + SharedDtor(); +} + +void ServerResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void ServerResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ServerResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ServerResponse_descriptor_; +} + +const ServerResponse& ServerResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + return *default_instance_; +} + +ServerResponse* ServerResponse::default_instance_ = NULL; + +ServerResponse* ServerResponse::New() const { + return new ServerResponse; +} + +void ServerResponse::Clear() { + attribute_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ServerResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.ServerResponse) + 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 .bgs.protocol.Attribute attribute = 1; + case 1: { + if (tag == 10) { + parse_attribute: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_attribute())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_attribute; + 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:bgs.protocol.game_utilities.v1.ServerResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.ServerResponse) + return false; +#undef DO_ +} + +void ServerResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.ServerResponse) + // repeated .bgs.protocol.Attribute attribute = 1; + for (int i = 0; i < this->attribute_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->attribute(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.ServerResponse) +} + +::google::protobuf::uint8* ServerResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.ServerResponse) + // repeated .bgs.protocol.Attribute attribute = 1; + for (int i = 0; i < this->attribute_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->attribute(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.ServerResponse) + return target; +} + +int ServerResponse::ByteSize() const { + int total_size = 0; + + // repeated .bgs.protocol.Attribute attribute = 1; + total_size += 1 * this->attribute_size(); + for (int i = 0; i < this->attribute_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->attribute(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 ServerResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ServerResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ServerResponse::MergeFrom(const ServerResponse& from) { + GOOGLE_CHECK_NE(&from, this); + attribute_.MergeFrom(from.attribute_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ServerResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ServerResponse::CopyFrom(const ServerResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ServerResponse::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false; + return true; +} + +void ServerResponse::Swap(ServerResponse* other) { + if (other != this) { + attribute_.Swap(&other->attribute_); + 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 ServerResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ServerResponse_descriptor_; + metadata.reflection = ServerResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int PresenceChannelCreatedRequest::kIdFieldNumber; +const int PresenceChannelCreatedRequest::kGameAccountIdFieldNumber; +const int PresenceChannelCreatedRequest::kAccountIdFieldNumber; +const int PresenceChannelCreatedRequest::kHostFieldNumber; +#endif // !_MSC_VER + +PresenceChannelCreatedRequest::PresenceChannelCreatedRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest) +} + +void PresenceChannelCreatedRequest::InitAsDefaultInstance() { + id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + host_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance()); +} + +PresenceChannelCreatedRequest::PresenceChannelCreatedRequest(const PresenceChannelCreatedRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest) +} + +void PresenceChannelCreatedRequest::SharedCtor() { + _cached_size_ = 0; + id_ = NULL; + game_account_id_ = NULL; + account_id_ = NULL; + host_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +PresenceChannelCreatedRequest::~PresenceChannelCreatedRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest) + SharedDtor(); +} + +void PresenceChannelCreatedRequest::SharedDtor() { + if (this != default_instance_) { + delete id_; + delete game_account_id_; + delete account_id_; + delete host_; + } +} + +void PresenceChannelCreatedRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* PresenceChannelCreatedRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return PresenceChannelCreatedRequest_descriptor_; +} + +const PresenceChannelCreatedRequest& PresenceChannelCreatedRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + return *default_instance_; +} + +PresenceChannelCreatedRequest* PresenceChannelCreatedRequest::default_instance_ = NULL; + +PresenceChannelCreatedRequest* PresenceChannelCreatedRequest::New() const { + return new PresenceChannelCreatedRequest; +} + +void PresenceChannelCreatedRequest::Clear() { + if (_has_bits_[0 / 32] & 15) { + if (has_id()) { + if (id_ != NULL) id_->::bgs::protocol::EntityId::Clear(); + } + if (has_game_account_id()) { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_account_id()) { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_host()) { + if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool PresenceChannelCreatedRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest) + 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)) { + // required .bgs.protocol.EntityId id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_game_account_id; + break; + } + + // optional .bgs.protocol.EntityId game_account_id = 3; + case 3: { + if (tag == 26) { + parse_game_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_account_id; + break; + } + + // optional .bgs.protocol.EntityId account_id = 4; + case 4: { + if (tag == 34) { + parse_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_host; + break; + } + + // optional .bgs.protocol.ProcessId host = 5; + case 5: { + if (tag == 42) { + parse_host: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_host())); + } 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:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest) + return false; +#undef DO_ +} + +void PresenceChannelCreatedRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest) + // required .bgs.protocol.EntityId id = 1; + if (has_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->id(), output); + } + + // optional .bgs.protocol.EntityId game_account_id = 3; + if (has_game_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->game_account_id(), output); + } + + // optional .bgs.protocol.EntityId account_id = 4; + if (has_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->account_id(), output); + } + + // optional .bgs.protocol.ProcessId host = 5; + if (has_host()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, this->host(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest) +} + +::google::protobuf::uint8* PresenceChannelCreatedRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest) + // required .bgs.protocol.EntityId id = 1; + if (has_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->id(), target); + } + + // optional .bgs.protocol.EntityId game_account_id = 3; + if (has_game_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->game_account_id(), target); + } + + // optional .bgs.protocol.EntityId account_id = 4; + if (has_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->account_id(), target); + } + + // optional .bgs.protocol.ProcessId host = 5; + if (has_host()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 5, this->host(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest) + return target; +} + +int PresenceChannelCreatedRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.EntityId id = 1; + if (has_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->id()); + } + + // optional .bgs.protocol.EntityId game_account_id = 3; + if (has_game_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account_id()); + } + + // optional .bgs.protocol.EntityId account_id = 4; + if (has_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account_id()); + } + + // optional .bgs.protocol.ProcessId host = 5; + if (has_host()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->host()); + } + + } + 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 PresenceChannelCreatedRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const PresenceChannelCreatedRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void PresenceChannelCreatedRequest::MergeFrom(const PresenceChannelCreatedRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_id()) { + mutable_id()->::bgs::protocol::EntityId::MergeFrom(from.id()); + } + if (from.has_game_account_id()) { + mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id()); + } + if (from.has_account_id()) { + mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id()); + } + if (from.has_host()) { + mutable_host()->::bgs::protocol::ProcessId::MergeFrom(from.host()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void PresenceChannelCreatedRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void PresenceChannelCreatedRequest::CopyFrom(const PresenceChannelCreatedRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PresenceChannelCreatedRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_id()) { + if (!this->id().IsInitialized()) return false; + } + if (has_game_account_id()) { + if (!this->game_account_id().IsInitialized()) return false; + } + if (has_account_id()) { + if (!this->account_id().IsInitialized()) return false; + } + if (has_host()) { + if (!this->host().IsInitialized()) return false; + } + return true; +} + +void PresenceChannelCreatedRequest::Swap(PresenceChannelCreatedRequest* other) { + if (other != this) { + std::swap(id_, other->id_); + std::swap(game_account_id_, other->game_account_id_); + std::swap(account_id_, other->account_id_); + std::swap(host_, other->host_); + 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 PresenceChannelCreatedRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = PresenceChannelCreatedRequest_descriptor_; + metadata.reflection = PresenceChannelCreatedRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GetPlayerVariablesRequest::kPlayerVariablesFieldNumber; +const int GetPlayerVariablesRequest::kHostFieldNumber; +#endif // !_MSC_VER + +GetPlayerVariablesRequest::GetPlayerVariablesRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest) +} + +void GetPlayerVariablesRequest::InitAsDefaultInstance() { + host_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance()); +} + +GetPlayerVariablesRequest::GetPlayerVariablesRequest(const GetPlayerVariablesRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest) +} + +void GetPlayerVariablesRequest::SharedCtor() { + _cached_size_ = 0; + host_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GetPlayerVariablesRequest::~GetPlayerVariablesRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest) + SharedDtor(); +} + +void GetPlayerVariablesRequest::SharedDtor() { + if (this != default_instance_) { + delete host_; + } +} + +void GetPlayerVariablesRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GetPlayerVariablesRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GetPlayerVariablesRequest_descriptor_; +} + +const GetPlayerVariablesRequest& GetPlayerVariablesRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + return *default_instance_; +} + +GetPlayerVariablesRequest* GetPlayerVariablesRequest::default_instance_ = NULL; + +GetPlayerVariablesRequest* GetPlayerVariablesRequest::New() const { + return new GetPlayerVariablesRequest; +} + +void GetPlayerVariablesRequest::Clear() { + if (has_host()) { + if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear(); + } + player_variables_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GetPlayerVariablesRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest) + 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 .bgs.protocol.game_utilities.v1.PlayerVariables player_variables = 1; + case 1: { + if (tag == 10) { + parse_player_variables: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_player_variables())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_player_variables; + if (input->ExpectTag(18)) goto parse_host; + break; + } + + // optional .bgs.protocol.ProcessId host = 2; + case 2: { + if (tag == 18) { + parse_host: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_host())); + } 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:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest) + return false; +#undef DO_ +} + +void GetPlayerVariablesRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest) + // repeated .bgs.protocol.game_utilities.v1.PlayerVariables player_variables = 1; + for (int i = 0; i < this->player_variables_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->player_variables(i), output); + } + + // optional .bgs.protocol.ProcessId host = 2; + if (has_host()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->host(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest) +} + +::google::protobuf::uint8* GetPlayerVariablesRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest) + // repeated .bgs.protocol.game_utilities.v1.PlayerVariables player_variables = 1; + for (int i = 0; i < this->player_variables_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->player_variables(i), target); + } + + // optional .bgs.protocol.ProcessId host = 2; + if (has_host()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->host(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest) + return target; +} + +int GetPlayerVariablesRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) { + // optional .bgs.protocol.ProcessId host = 2; + if (has_host()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->host()); + } + + } + // repeated .bgs.protocol.game_utilities.v1.PlayerVariables player_variables = 1; + total_size += 1 * this->player_variables_size(); + for (int i = 0; i < this->player_variables_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->player_variables(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 GetPlayerVariablesRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GetPlayerVariablesRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GetPlayerVariablesRequest::MergeFrom(const GetPlayerVariablesRequest& from) { + GOOGLE_CHECK_NE(&from, this); + player_variables_.MergeFrom(from.player_variables_); + if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) { + if (from.has_host()) { + mutable_host()->::bgs::protocol::ProcessId::MergeFrom(from.host()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GetPlayerVariablesRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetPlayerVariablesRequest::CopyFrom(const GetPlayerVariablesRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetPlayerVariablesRequest::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->player_variables())) return false; + if (has_host()) { + if (!this->host().IsInitialized()) return false; + } + return true; +} + +void GetPlayerVariablesRequest::Swap(GetPlayerVariablesRequest* other) { + if (other != this) { + player_variables_.Swap(&other->player_variables_); + std::swap(host_, other->host_); + 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 GetPlayerVariablesRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GetPlayerVariablesRequest_descriptor_; + metadata.reflection = GetPlayerVariablesRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GetPlayerVariablesResponse::kPlayerVariablesFieldNumber; +#endif // !_MSC_VER + +GetPlayerVariablesResponse::GetPlayerVariablesResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse) +} + +void GetPlayerVariablesResponse::InitAsDefaultInstance() { +} + +GetPlayerVariablesResponse::GetPlayerVariablesResponse(const GetPlayerVariablesResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse) +} + +void GetPlayerVariablesResponse::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GetPlayerVariablesResponse::~GetPlayerVariablesResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse) + SharedDtor(); +} + +void GetPlayerVariablesResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void GetPlayerVariablesResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GetPlayerVariablesResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GetPlayerVariablesResponse_descriptor_; +} + +const GetPlayerVariablesResponse& GetPlayerVariablesResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + return *default_instance_; +} + +GetPlayerVariablesResponse* GetPlayerVariablesResponse::default_instance_ = NULL; + +GetPlayerVariablesResponse* GetPlayerVariablesResponse::New() const { + return new GetPlayerVariablesResponse; +} + +void GetPlayerVariablesResponse::Clear() { + player_variables_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GetPlayerVariablesResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse) + 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 .bgs.protocol.game_utilities.v1.PlayerVariables player_variables = 1; + case 1: { + if (tag == 10) { + parse_player_variables: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_player_variables())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_player_variables; + 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:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse) + return false; +#undef DO_ +} + +void GetPlayerVariablesResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse) + // repeated .bgs.protocol.game_utilities.v1.PlayerVariables player_variables = 1; + for (int i = 0; i < this->player_variables_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->player_variables(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse) +} + +::google::protobuf::uint8* GetPlayerVariablesResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse) + // repeated .bgs.protocol.game_utilities.v1.PlayerVariables player_variables = 1; + for (int i = 0; i < this->player_variables_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->player_variables(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse) + return target; +} + +int GetPlayerVariablesResponse::ByteSize() const { + int total_size = 0; + + // repeated .bgs.protocol.game_utilities.v1.PlayerVariables player_variables = 1; + total_size += 1 * this->player_variables_size(); + for (int i = 0; i < this->player_variables_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->player_variables(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 GetPlayerVariablesResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GetPlayerVariablesResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GetPlayerVariablesResponse::MergeFrom(const GetPlayerVariablesResponse& from) { + GOOGLE_CHECK_NE(&from, this); + player_variables_.MergeFrom(from.player_variables_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GetPlayerVariablesResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetPlayerVariablesResponse::CopyFrom(const GetPlayerVariablesResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetPlayerVariablesResponse::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->player_variables())) return false; + return true; +} + +void GetPlayerVariablesResponse::Swap(GetPlayerVariablesResponse* other) { + if (other != this) { + player_variables_.Swap(&other->player_variables_); + 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 GetPlayerVariablesResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GetPlayerVariablesResponse_descriptor_; + metadata.reflection = GetPlayerVariablesResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GameAccountOnlineNotification::kGameAccountIdFieldNumber; +const int GameAccountOnlineNotification::kHostFieldNumber; +const int GameAccountOnlineNotification::kSessionIdFieldNumber; +#endif // !_MSC_VER + +GameAccountOnlineNotification::GameAccountOnlineNotification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification) +} + +void GameAccountOnlineNotification::InitAsDefaultInstance() { + game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + host_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance()); +} + +GameAccountOnlineNotification::GameAccountOnlineNotification(const GameAccountOnlineNotification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification) +} + +void GameAccountOnlineNotification::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + game_account_id_ = NULL; + host_ = NULL; + session_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameAccountOnlineNotification::~GameAccountOnlineNotification() { + // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification) + SharedDtor(); +} + +void GameAccountOnlineNotification::SharedDtor() { + if (session_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete session_id_; + } + if (this != default_instance_) { + delete game_account_id_; + delete host_; + } +} + +void GameAccountOnlineNotification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GameAccountOnlineNotification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GameAccountOnlineNotification_descriptor_; +} + +const GameAccountOnlineNotification& GameAccountOnlineNotification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + return *default_instance_; +} + +GameAccountOnlineNotification* GameAccountOnlineNotification::default_instance_ = NULL; + +GameAccountOnlineNotification* GameAccountOnlineNotification::New() const { + return new GameAccountOnlineNotification; +} + +void GameAccountOnlineNotification::Clear() { + if (_has_bits_[0 / 32] & 7) { + if (has_game_account_id()) { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_host()) { + if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear(); + } + if (has_session_id()) { + if (session_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + session_id_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GameAccountOnlineNotification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification) + 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)) { + // required .bgs.protocol.EntityId game_account_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_host; + break; + } + + // optional .bgs.protocol.ProcessId host = 2; + case 2: { + if (tag == 18) { + parse_host: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_host())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_session_id; + break; + } + + // optional string session_id = 3; + case 3: { + if (tag == 26) { + parse_session_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_session_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->session_id().data(), this->session_id().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "session_id"); + } 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:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification) + return false; +#undef DO_ +} + +void GameAccountOnlineNotification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification) + // required .bgs.protocol.EntityId game_account_id = 1; + if (has_game_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->game_account_id(), output); + } + + // optional .bgs.protocol.ProcessId host = 2; + if (has_host()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->host(), output); + } + + // optional string session_id = 3; + if (has_session_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->session_id().data(), this->session_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "session_id"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->session_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification) +} + +::google::protobuf::uint8* GameAccountOnlineNotification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification) + // required .bgs.protocol.EntityId game_account_id = 1; + if (has_game_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->game_account_id(), target); + } + + // optional .bgs.protocol.ProcessId host = 2; + if (has_host()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->host(), target); + } + + // optional string session_id = 3; + if (has_session_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->session_id().data(), this->session_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "session_id"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->session_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification) + return target; +} + +int GameAccountOnlineNotification::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.EntityId game_account_id = 1; + if (has_game_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account_id()); + } + + // optional .bgs.protocol.ProcessId host = 2; + if (has_host()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->host()); + } + + // optional string session_id = 3; + if (has_session_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->session_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void GameAccountOnlineNotification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GameAccountOnlineNotification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GameAccountOnlineNotification::MergeFrom(const GameAccountOnlineNotification& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_game_account_id()) { + mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id()); + } + if (from.has_host()) { + mutable_host()->::bgs::protocol::ProcessId::MergeFrom(from.host()); + } + if (from.has_session_id()) { + set_session_id(from.session_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GameAccountOnlineNotification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GameAccountOnlineNotification::CopyFrom(const GameAccountOnlineNotification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameAccountOnlineNotification::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_game_account_id()) { + if (!this->game_account_id().IsInitialized()) return false; + } + if (has_host()) { + if (!this->host().IsInitialized()) return false; + } + return true; +} + +void GameAccountOnlineNotification::Swap(GameAccountOnlineNotification* other) { + if (other != this) { + std::swap(game_account_id_, other->game_account_id_); + std::swap(host_, other->host_); + std::swap(session_id_, other->session_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata GameAccountOnlineNotification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GameAccountOnlineNotification_descriptor_; + metadata.reflection = GameAccountOnlineNotification_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GameAccountOfflineNotification::kGameAccountIdFieldNumber; +const int GameAccountOfflineNotification::kHostFieldNumber; +const int GameAccountOfflineNotification::kSessionIdFieldNumber; +#endif // !_MSC_VER + +GameAccountOfflineNotification::GameAccountOfflineNotification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification) +} + +void GameAccountOfflineNotification::InitAsDefaultInstance() { + game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + host_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance()); +} + +GameAccountOfflineNotification::GameAccountOfflineNotification(const GameAccountOfflineNotification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification) +} + +void GameAccountOfflineNotification::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + game_account_id_ = NULL; + host_ = NULL; + session_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameAccountOfflineNotification::~GameAccountOfflineNotification() { + // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification) + SharedDtor(); +} + +void GameAccountOfflineNotification::SharedDtor() { + if (session_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete session_id_; + } + if (this != default_instance_) { + delete game_account_id_; + delete host_; + } +} + +void GameAccountOfflineNotification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GameAccountOfflineNotification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GameAccountOfflineNotification_descriptor_; +} + +const GameAccountOfflineNotification& GameAccountOfflineNotification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + return *default_instance_; +} + +GameAccountOfflineNotification* GameAccountOfflineNotification::default_instance_ = NULL; + +GameAccountOfflineNotification* GameAccountOfflineNotification::New() const { + return new GameAccountOfflineNotification; +} + +void GameAccountOfflineNotification::Clear() { + if (_has_bits_[0 / 32] & 7) { + if (has_game_account_id()) { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_host()) { + if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear(); + } + if (has_session_id()) { + if (session_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + session_id_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GameAccountOfflineNotification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification) + 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)) { + // required .bgs.protocol.EntityId game_account_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_host; + break; + } + + // optional .bgs.protocol.ProcessId host = 2; + case 2: { + if (tag == 18) { + parse_host: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_host())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_session_id; + break; + } + + // optional string session_id = 3; + case 3: { + if (tag == 26) { + parse_session_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_session_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->session_id().data(), this->session_id().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "session_id"); + } 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:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification) + return false; +#undef DO_ +} + +void GameAccountOfflineNotification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification) + // required .bgs.protocol.EntityId game_account_id = 1; + if (has_game_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->game_account_id(), output); + } + + // optional .bgs.protocol.ProcessId host = 2; + if (has_host()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->host(), output); + } + + // optional string session_id = 3; + if (has_session_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->session_id().data(), this->session_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "session_id"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->session_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification) +} + +::google::protobuf::uint8* GameAccountOfflineNotification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification) + // required .bgs.protocol.EntityId game_account_id = 1; + if (has_game_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->game_account_id(), target); + } + + // optional .bgs.protocol.ProcessId host = 2; + if (has_host()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->host(), target); + } + + // optional string session_id = 3; + if (has_session_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->session_id().data(), this->session_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "session_id"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->session_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification) + return target; +} + +int GameAccountOfflineNotification::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.EntityId game_account_id = 1; + if (has_game_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account_id()); + } + + // optional .bgs.protocol.ProcessId host = 2; + if (has_host()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->host()); + } + + // optional string session_id = 3; + if (has_session_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->session_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void GameAccountOfflineNotification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GameAccountOfflineNotification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GameAccountOfflineNotification::MergeFrom(const GameAccountOfflineNotification& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_game_account_id()) { + mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id()); + } + if (from.has_host()) { + mutable_host()->::bgs::protocol::ProcessId::MergeFrom(from.host()); + } + if (from.has_session_id()) { + set_session_id(from.session_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GameAccountOfflineNotification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GameAccountOfflineNotification::CopyFrom(const GameAccountOfflineNotification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameAccountOfflineNotification::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_game_account_id()) { + if (!this->game_account_id().IsInitialized()) return false; + } + if (has_host()) { + if (!this->host().IsInitialized()) return false; + } + return true; +} + +void GameAccountOfflineNotification::Swap(GameAccountOfflineNotification* other) { + if (other != this) { + std::swap(game_account_id_, other->game_account_id_); + std::swap(host_, other->host_); + std::swap(session_id_, other->session_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata GameAccountOfflineNotification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GameAccountOfflineNotification_descriptor_; + metadata.reflection = GameAccountOfflineNotification_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GetAchievementsFileRequest::kHostFieldNumber; +#endif // !_MSC_VER + +GetAchievementsFileRequest::GetAchievementsFileRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest) +} + +void GetAchievementsFileRequest::InitAsDefaultInstance() { + host_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance()); +} + +GetAchievementsFileRequest::GetAchievementsFileRequest(const GetAchievementsFileRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest) +} + +void GetAchievementsFileRequest::SharedCtor() { + _cached_size_ = 0; + host_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GetAchievementsFileRequest::~GetAchievementsFileRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest) + SharedDtor(); +} + +void GetAchievementsFileRequest::SharedDtor() { + if (this != default_instance_) { + delete host_; + } +} + +void GetAchievementsFileRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GetAchievementsFileRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GetAchievementsFileRequest_descriptor_; +} + +const GetAchievementsFileRequest& GetAchievementsFileRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + return *default_instance_; +} + +GetAchievementsFileRequest* GetAchievementsFileRequest::default_instance_ = NULL; + +GetAchievementsFileRequest* GetAchievementsFileRequest::New() const { + return new GetAchievementsFileRequest; +} + +void GetAchievementsFileRequest::Clear() { + if (has_host()) { + if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear(); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GetAchievementsFileRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest) + 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 .bgs.protocol.ProcessId host = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_host())); + } 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:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest) + return false; +#undef DO_ +} + +void GetAchievementsFileRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest) + // optional .bgs.protocol.ProcessId host = 1; + if (has_host()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->host(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest) +} + +::google::protobuf::uint8* GetAchievementsFileRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest) + // optional .bgs.protocol.ProcessId host = 1; + if (has_host()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->host(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest) + return target; +} + +int GetAchievementsFileRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.ProcessId host = 1; + if (has_host()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->host()); + } + + } + 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 GetAchievementsFileRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GetAchievementsFileRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GetAchievementsFileRequest::MergeFrom(const GetAchievementsFileRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_host()) { + mutable_host()->::bgs::protocol::ProcessId::MergeFrom(from.host()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GetAchievementsFileRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetAchievementsFileRequest::CopyFrom(const GetAchievementsFileRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetAchievementsFileRequest::IsInitialized() const { + + if (has_host()) { + if (!this->host().IsInitialized()) return false; + } + return true; +} + +void GetAchievementsFileRequest::Swap(GetAchievementsFileRequest* other) { + if (other != this) { + std::swap(host_, other->host_); + 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 GetAchievementsFileRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GetAchievementsFileRequest_descriptor_; + metadata.reflection = GetAchievementsFileRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GetAchievementsFileResponse::kContentHandleFieldNumber; +#endif // !_MSC_VER + +GetAchievementsFileResponse::GetAchievementsFileResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse) +} + +void GetAchievementsFileResponse::InitAsDefaultInstance() { + content_handle_ = const_cast< ::bgs::protocol::ContentHandle*>(&::bgs::protocol::ContentHandle::default_instance()); +} + +GetAchievementsFileResponse::GetAchievementsFileResponse(const GetAchievementsFileResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse) +} + +void GetAchievementsFileResponse::SharedCtor() { + _cached_size_ = 0; + content_handle_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GetAchievementsFileResponse::~GetAchievementsFileResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse) + SharedDtor(); +} + +void GetAchievementsFileResponse::SharedDtor() { + if (this != default_instance_) { + delete content_handle_; + } +} + +void GetAchievementsFileResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GetAchievementsFileResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GetAchievementsFileResponse_descriptor_; +} + +const GetAchievementsFileResponse& GetAchievementsFileResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + return *default_instance_; +} + +GetAchievementsFileResponse* GetAchievementsFileResponse::default_instance_ = NULL; + +GetAchievementsFileResponse* GetAchievementsFileResponse::New() const { + return new GetAchievementsFileResponse; +} + +void GetAchievementsFileResponse::Clear() { + if (has_content_handle()) { + if (content_handle_ != NULL) content_handle_->::bgs::protocol::ContentHandle::Clear(); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GetAchievementsFileResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse) + 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 .bgs.protocol.ContentHandle content_handle = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_content_handle())); + } 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:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse) + return false; +#undef DO_ +} + +void GetAchievementsFileResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse) + // optional .bgs.protocol.ContentHandle content_handle = 1; + if (has_content_handle()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->content_handle(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse) +} + +::google::protobuf::uint8* GetAchievementsFileResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse) + // optional .bgs.protocol.ContentHandle content_handle = 1; + if (has_content_handle()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->content_handle(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse) + return target; +} + +int GetAchievementsFileResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.ContentHandle content_handle = 1; + if (has_content_handle()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->content_handle()); + } + + } + 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 GetAchievementsFileResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GetAchievementsFileResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GetAchievementsFileResponse::MergeFrom(const GetAchievementsFileResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_content_handle()) { + mutable_content_handle()->::bgs::protocol::ContentHandle::MergeFrom(from.content_handle()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GetAchievementsFileResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetAchievementsFileResponse::CopyFrom(const GetAchievementsFileResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetAchievementsFileResponse::IsInitialized() const { + + if (has_content_handle()) { + if (!this->content_handle().IsInitialized()) return false; + } + return true; +} + +void GetAchievementsFileResponse::Swap(GetAchievementsFileResponse* other) { + if (other != this) { + std::swap(content_handle_, other->content_handle_); + 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 GetAchievementsFileResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GetAchievementsFileResponse_descriptor_; + metadata.reflection = GetAchievementsFileResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GetAllValuesForAttributeRequest::kAttributeKeyFieldNumber; +const int GetAllValuesForAttributeRequest::kAgentIdFieldNumber; +const int GetAllValuesForAttributeRequest::kProgramFieldNumber; +#endif // !_MSC_VER + +GetAllValuesForAttributeRequest::GetAllValuesForAttributeRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest) +} + +void GetAllValuesForAttributeRequest::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +GetAllValuesForAttributeRequest::GetAllValuesForAttributeRequest(const GetAllValuesForAttributeRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest) +} + +void GetAllValuesForAttributeRequest::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + attribute_key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + agent_id_ = NULL; + program_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GetAllValuesForAttributeRequest::~GetAllValuesForAttributeRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest) + SharedDtor(); +} + +void GetAllValuesForAttributeRequest::SharedDtor() { + if (attribute_key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete attribute_key_; + } + if (this != default_instance_) { + delete agent_id_; + } +} + +void GetAllValuesForAttributeRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GetAllValuesForAttributeRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GetAllValuesForAttributeRequest_descriptor_; +} + +const GetAllValuesForAttributeRequest& GetAllValuesForAttributeRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + return *default_instance_; +} + +GetAllValuesForAttributeRequest* GetAllValuesForAttributeRequest::default_instance_ = NULL; + +GetAllValuesForAttributeRequest* GetAllValuesForAttributeRequest::New() const { + return new GetAllValuesForAttributeRequest; +} + +void GetAllValuesForAttributeRequest::Clear() { + if (_has_bits_[0 / 32] & 7) { + if (has_attribute_key()) { + if (attribute_key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + attribute_key_->clear(); + } + } + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + program_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GetAllValuesForAttributeRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest) + 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 attribute_key = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_attribute_key())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->attribute_key().data(), this->attribute_key().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "attribute_key"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_agent_id; + break; + } + + // optional .bgs.protocol.EntityId agent_id = 2; + case 2: { + if (tag == 18) { + parse_agent_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(45)) goto parse_program; + break; + } + + // optional fixed32 program = 5; + case 5: { + if (tag == 45) { + parse_program: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &program_))); + set_has_program(); + } 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:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest) + return false; +#undef DO_ +} + +void GetAllValuesForAttributeRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest) + // optional string attribute_key = 1; + if (has_attribute_key()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->attribute_key().data(), this->attribute_key().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "attribute_key"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->attribute_key(), output); + } + + // optional .bgs.protocol.EntityId agent_id = 2; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->agent_id(), output); + } + + // optional fixed32 program = 5; + if (has_program()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->program(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest) +} + +::google::protobuf::uint8* GetAllValuesForAttributeRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest) + // optional string attribute_key = 1; + if (has_attribute_key()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->attribute_key().data(), this->attribute_key().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "attribute_key"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->attribute_key(), target); + } + + // optional .bgs.protocol.EntityId agent_id = 2; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->agent_id(), target); + } + + // optional fixed32 program = 5; + if (has_program()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->program(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest) + return target; +} + +int GetAllValuesForAttributeRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional string attribute_key = 1; + if (has_attribute_key()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->attribute_key()); + } + + // optional .bgs.protocol.EntityId agent_id = 2; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // optional fixed32 program = 5; + if (has_program()) { + 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 GetAllValuesForAttributeRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GetAllValuesForAttributeRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GetAllValuesForAttributeRequest::MergeFrom(const GetAllValuesForAttributeRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_attribute_key()) { + set_attribute_key(from.attribute_key()); + } + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_program()) { + set_program(from.program()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GetAllValuesForAttributeRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetAllValuesForAttributeRequest::CopyFrom(const GetAllValuesForAttributeRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetAllValuesForAttributeRequest::IsInitialized() const { + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + return true; +} + +void GetAllValuesForAttributeRequest::Swap(GetAllValuesForAttributeRequest* other) { + if (other != this) { + std::swap(attribute_key_, other->attribute_key_); + std::swap(agent_id_, other->agent_id_); + std::swap(program_, other->program_); + 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 GetAllValuesForAttributeRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GetAllValuesForAttributeRequest_descriptor_; + metadata.reflection = GetAllValuesForAttributeRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GetAllValuesForAttributeResponse::kAttributeValueFieldNumber; +#endif // !_MSC_VER + +GetAllValuesForAttributeResponse::GetAllValuesForAttributeResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse) +} + +void GetAllValuesForAttributeResponse::InitAsDefaultInstance() { +} + +GetAllValuesForAttributeResponse::GetAllValuesForAttributeResponse(const GetAllValuesForAttributeResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse) +} + +void GetAllValuesForAttributeResponse::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GetAllValuesForAttributeResponse::~GetAllValuesForAttributeResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse) + SharedDtor(); +} + +void GetAllValuesForAttributeResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void GetAllValuesForAttributeResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GetAllValuesForAttributeResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GetAllValuesForAttributeResponse_descriptor_; +} + +const GetAllValuesForAttributeResponse& GetAllValuesForAttributeResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + return *default_instance_; +} + +GetAllValuesForAttributeResponse* GetAllValuesForAttributeResponse::default_instance_ = NULL; + +GetAllValuesForAttributeResponse* GetAllValuesForAttributeResponse::New() const { + return new GetAllValuesForAttributeResponse; +} + +void GetAllValuesForAttributeResponse::Clear() { + attribute_value_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GetAllValuesForAttributeResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse) + 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 .bgs.protocol.Variant attribute_value = 1; + case 1: { + if (tag == 10) { + parse_attribute_value: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_attribute_value())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_attribute_value; + 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:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse) + return false; +#undef DO_ +} + +void GetAllValuesForAttributeResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse) + // repeated .bgs.protocol.Variant attribute_value = 1; + for (int i = 0; i < this->attribute_value_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->attribute_value(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse) +} + +::google::protobuf::uint8* GetAllValuesForAttributeResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse) + // repeated .bgs.protocol.Variant attribute_value = 1; + for (int i = 0; i < this->attribute_value_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->attribute_value(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse) + return target; +} + +int GetAllValuesForAttributeResponse::ByteSize() const { + int total_size = 0; + + // repeated .bgs.protocol.Variant attribute_value = 1; + total_size += 1 * this->attribute_value_size(); + for (int i = 0; i < this->attribute_value_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->attribute_value(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 GetAllValuesForAttributeResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GetAllValuesForAttributeResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GetAllValuesForAttributeResponse::MergeFrom(const GetAllValuesForAttributeResponse& from) { + GOOGLE_CHECK_NE(&from, this); + attribute_value_.MergeFrom(from.attribute_value_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GetAllValuesForAttributeResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetAllValuesForAttributeResponse::CopyFrom(const GetAllValuesForAttributeResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetAllValuesForAttributeResponse::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->attribute_value())) return false; + return true; +} + +void GetAllValuesForAttributeResponse::Swap(GetAllValuesForAttributeResponse* other) { + if (other != this) { + attribute_value_.Swap(&other->attribute_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 GetAllValuesForAttributeResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GetAllValuesForAttributeResponse_descriptor_; + metadata.reflection = GetAllValuesForAttributeResponse_reflection_; + return metadata; +} + + +// =================================================================== + +google::protobuf::ServiceDescriptor const* GameUtilitiesService::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GameUtilitiesService_descriptor_; +} + +void GameUtilitiesService::ProcessClientRequest(::bgs::protocol::game_utilities::v1::ClientRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method GameUtilitiesService.ProcessClientRequest(bgs.protocol.game_utilities.v1.ClientRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 1, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::game_utilities::v1::ClientResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void GameUtilitiesService::PresenceChannelCreated(::bgs::protocol::game_utilities::v1::PresenceChannelCreatedRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method GameUtilitiesService.PresenceChannelCreated(bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 2, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void GameUtilitiesService::GetPlayerVariables(::bgs::protocol::game_utilities::v1::GetPlayerVariablesRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method GameUtilitiesService.GetPlayerVariables(bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 3, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::game_utilities::v1::GetPlayerVariablesResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void GameUtilitiesService::ProcessServerRequest(::bgs::protocol::game_utilities::v1::ServerRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method GameUtilitiesService.ProcessServerRequest(bgs.protocol.game_utilities.v1.ServerRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 6, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::game_utilities::v1::ServerResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void GameUtilitiesService::OnGameAccountOnline(::bgs::protocol::game_utilities::v1::GameAccountOnlineNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method GameUtilitiesService.OnGameAccountOnline(bgs.protocol.game_utilities.v1.GameAccountOnlineNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 7, request); +} + +void GameUtilitiesService::OnGameAccountOffline(::bgs::protocol::game_utilities::v1::GameAccountOfflineNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method GameUtilitiesService.OnGameAccountOffline(bgs.protocol.game_utilities.v1.GameAccountOfflineNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 8, request); +} + +void GameUtilitiesService::GetAchievementsFile(::bgs::protocol::game_utilities::v1::GetAchievementsFileRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method GameUtilitiesService.GetAchievementsFile(bgs.protocol.game_utilities.v1.GetAchievementsFileRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 9, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::game_utilities::v1::GetAchievementsFileResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void GameUtilitiesService::GetAllValuesForAttribute(::bgs::protocol::game_utilities::v1::GetAllValuesForAttributeRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method GameUtilitiesService.GetAllValuesForAttribute(bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 10, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::game_utilities::v1::GetAllValuesForAttributeResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void GameUtilitiesService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) { + switch(methodId) { + case 1: { + ::bgs::protocol::game_utilities::v1::ClientRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for GameUtilitiesService.ProcessClientRequest server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::game_utilities::v1::ClientResponse response; + uint32 status = HandleProcessClientRequest(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method GameUtilitiesService.ProcessClientRequest(bgs.protocol.game_utilities.v1.ClientRequest{ %s }) returned bgs.protocol.game_utilities.v1.ClientResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 1, token, &response); + else + SendResponse(service_hash_, 1, token, status); + break; + } + case 2: { + ::bgs::protocol::game_utilities::v1::PresenceChannelCreatedRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for GameUtilitiesService.PresenceChannelCreated server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandlePresenceChannelCreated(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method GameUtilitiesService.PresenceChannelCreated(bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 2, token, &response); + else + SendResponse(service_hash_, 2, token, status); + break; + } + case 3: { + ::bgs::protocol::game_utilities::v1::GetPlayerVariablesRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for GameUtilitiesService.GetPlayerVariables server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::game_utilities::v1::GetPlayerVariablesResponse response; + uint32 status = HandleGetPlayerVariables(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method GameUtilitiesService.GetPlayerVariables(bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest{ %s }) returned bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 3, token, &response); + else + SendResponse(service_hash_, 3, token, status); + break; + } + case 6: { + ::bgs::protocol::game_utilities::v1::ServerRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for GameUtilitiesService.ProcessServerRequest server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 6, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::game_utilities::v1::ServerResponse response; + uint32 status = HandleProcessServerRequest(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method GameUtilitiesService.ProcessServerRequest(bgs.protocol.game_utilities.v1.ServerRequest{ %s }) returned bgs.protocol.game_utilities.v1.ServerResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 6, token, &response); + else + SendResponse(service_hash_, 6, token, status); + break; + } + case 7: { + ::bgs::protocol::game_utilities::v1::GameAccountOnlineNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for GameUtilitiesService.OnGameAccountOnline server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 7, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnGameAccountOnline(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method GameUtilitiesService.OnGameAccountOnline(bgs.protocol.game_utilities.v1.GameAccountOnlineNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 7, token, status); + break; + } + case 8: { + ::bgs::protocol::game_utilities::v1::GameAccountOfflineNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for GameUtilitiesService.OnGameAccountOffline server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 8, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnGameAccountOffline(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method GameUtilitiesService.OnGameAccountOffline(bgs.protocol.game_utilities.v1.GameAccountOfflineNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 8, token, status); + break; + } + case 9: { + ::bgs::protocol::game_utilities::v1::GetAchievementsFileRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for GameUtilitiesService.GetAchievementsFile server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 9, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::game_utilities::v1::GetAchievementsFileResponse response; + uint32 status = HandleGetAchievementsFile(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method GameUtilitiesService.GetAchievementsFile(bgs.protocol.game_utilities.v1.GetAchievementsFileRequest{ %s }) returned bgs.protocol.game_utilities.v1.GetAchievementsFileResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 9, token, &response); + else + SendResponse(service_hash_, 9, token, status); + break; + } + case 10: { + ::bgs::protocol::game_utilities::v1::GetAllValuesForAttributeRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for GameUtilitiesService.GetAllValuesForAttribute server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 10, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::game_utilities::v1::GetAllValuesForAttributeResponse response; + uint32 status = HandleGetAllValuesForAttribute(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method GameUtilitiesService.GetAllValuesForAttribute(bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest{ %s }) returned bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 10, token, &response); + else + SendResponse(service_hash_, 10, token, status); + break; + } + default: + TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId); + SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD); + break; + } +} + +uint32 GameUtilitiesService::HandleProcessClientRequest(::bgs::protocol::game_utilities::v1::ClientRequest const* request, ::bgs::protocol::game_utilities::v1::ClientResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method GameUtilitiesService.ProcessClientRequest({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 GameUtilitiesService::HandlePresenceChannelCreated(::bgs::protocol::game_utilities::v1::PresenceChannelCreatedRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method GameUtilitiesService.PresenceChannelCreated({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 GameUtilitiesService::HandleGetPlayerVariables(::bgs::protocol::game_utilities::v1::GetPlayerVariablesRequest const* request, ::bgs::protocol::game_utilities::v1::GetPlayerVariablesResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method GameUtilitiesService.GetPlayerVariables({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 GameUtilitiesService::HandleProcessServerRequest(::bgs::protocol::game_utilities::v1::ServerRequest const* request, ::bgs::protocol::game_utilities::v1::ServerResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method GameUtilitiesService.ProcessServerRequest({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 GameUtilitiesService::HandleOnGameAccountOnline(::bgs::protocol::game_utilities::v1::GameAccountOnlineNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method GameUtilitiesService.OnGameAccountOnline({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 GameUtilitiesService::HandleOnGameAccountOffline(::bgs::protocol::game_utilities::v1::GameAccountOfflineNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method GameUtilitiesService.OnGameAccountOffline({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 GameUtilitiesService::HandleGetAchievementsFile(::bgs::protocol::game_utilities::v1::GetAchievementsFileRequest const* request, ::bgs::protocol::game_utilities::v1::GetAchievementsFileResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method GameUtilitiesService.GetAchievementsFile({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 GameUtilitiesService::HandleGetAllValuesForAttribute(::bgs::protocol::game_utilities::v1::GetAllValuesForAttributeRequest const* request, ::bgs::protocol::game_utilities::v1::GetAllValuesForAttributeResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method GameUtilitiesService.GetAllValuesForAttribute({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace game_utilities +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/game_utilities_service.pb.h b/src/server/proto/Client/game_utilities_service.pb.h new file mode 100644 index 00000000000..511e6ad79b4 --- /dev/null +++ b/src/server/proto/Client/game_utilities_service.pb.h @@ -0,0 +1,2654 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: game_utilities_service.proto + +#ifndef PROTOBUF_game_5futilities_5fservice_2eproto__INCLUDED +#define PROTOBUF_game_5futilities_5fservice_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include "attribute_types.pb.h" +#include "content_handle_types.pb.h" +#include "entity_types.pb.h" +#include "game_utilities_types.pb.h" +#include "rpc_types.pb.h" +#include "ServiceBase.h" +#include "MessageBuffer.h" +#include +#include +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { +namespace game_utilities { +namespace v1 { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto(); +void protobuf_AssignDesc_game_5futilities_5fservice_2eproto(); +void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto(); + +class ClientRequest; +class ClientResponse; +class ServerRequest; +class ServerResponse; +class PresenceChannelCreatedRequest; +class GetPlayerVariablesRequest; +class GetPlayerVariablesResponse; +class GameAccountOnlineNotification; +class GameAccountOfflineNotification; +class GetAchievementsFileRequest; +class GetAchievementsFileResponse; +class GetAllValuesForAttributeRequest; +class GetAllValuesForAttributeResponse; + +// =================================================================== + +class TC_SHARED_API ClientRequest : public ::google::protobuf::Message { + public: + ClientRequest(); + virtual ~ClientRequest(); + + ClientRequest(const ClientRequest& from); + + inline ClientRequest& operator=(const ClientRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ClientRequest& default_instance(); + + void Swap(ClientRequest* other); + + // implements Message ---------------------------------------------- + + ClientRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ClientRequest& from); + void MergeFrom(const ClientRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.Attribute attribute = 1; + inline int attribute_size() const; + inline void clear_attribute(); + static const int kAttributeFieldNumber = 1; + inline const ::bgs::protocol::Attribute& attribute(int index) const; + inline ::bgs::protocol::Attribute* mutable_attribute(int index); + inline ::bgs::protocol::Attribute* add_attribute(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& + attribute() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* + mutable_attribute(); + + // optional .bgs.protocol.ProcessId host = 2; + inline bool has_host() const; + inline void clear_host(); + static const int kHostFieldNumber = 2; + inline const ::bgs::protocol::ProcessId& host() const; + inline ::bgs::protocol::ProcessId* mutable_host(); + inline ::bgs::protocol::ProcessId* release_host(); + inline void set_allocated_host(::bgs::protocol::ProcessId* host); + + // optional .bgs.protocol.EntityId account_id = 3; + inline bool has_account_id() const; + inline void clear_account_id(); + static const int kAccountIdFieldNumber = 3; + inline const ::bgs::protocol::EntityId& account_id() const; + inline ::bgs::protocol::EntityId* mutable_account_id(); + inline ::bgs::protocol::EntityId* release_account_id(); + inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id); + + // optional .bgs.protocol.EntityId game_account_id = 4; + inline bool has_game_account_id() const; + inline void clear_game_account_id(); + static const int kGameAccountIdFieldNumber = 4; + inline const ::bgs::protocol::EntityId& game_account_id() const; + inline ::bgs::protocol::EntityId* mutable_game_account_id(); + inline ::bgs::protocol::EntityId* release_game_account_id(); + inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id); + + // optional fixed32 program = 5; + inline bool has_program() const; + inline void clear_program(); + static const int kProgramFieldNumber = 5; + inline ::google::protobuf::uint32 program() const; + inline void set_program(::google::protobuf::uint32 value); + + // optional .bgs.protocol.game_utilities.v1.ClientInfo client_info = 6; + inline bool has_client_info() const; + inline void clear_client_info(); + static const int kClientInfoFieldNumber = 6; + inline const ::bgs::protocol::game_utilities::v1::ClientInfo& client_info() const; + inline ::bgs::protocol::game_utilities::v1::ClientInfo* mutable_client_info(); + inline ::bgs::protocol::game_utilities::v1::ClientInfo* release_client_info(); + inline void set_allocated_client_info(::bgs::protocol::game_utilities::v1::ClientInfo* client_info); + + // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.ClientRequest) + private: + inline void set_has_host(); + inline void clear_has_host(); + inline void set_has_account_id(); + inline void clear_has_account_id(); + inline void set_has_game_account_id(); + inline void clear_has_game_account_id(); + inline void set_has_program(); + inline void clear_has_program(); + inline void set_has_client_info(); + inline void clear_has_client_info(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_; + ::bgs::protocol::ProcessId* host_; + ::bgs::protocol::EntityId* account_id_; + ::bgs::protocol::EntityId* game_account_id_; + ::bgs::protocol::game_utilities::v1::ClientInfo* client_info_; + ::google::protobuf::uint32 program_; + friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ClientRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ClientResponse : public ::google::protobuf::Message { + public: + ClientResponse(); + virtual ~ClientResponse(); + + ClientResponse(const ClientResponse& from); + + inline ClientResponse& operator=(const ClientResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ClientResponse& default_instance(); + + void Swap(ClientResponse* other); + + // implements Message ---------------------------------------------- + + ClientResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ClientResponse& from); + void MergeFrom(const ClientResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.Attribute attribute = 1; + inline int attribute_size() const; + inline void clear_attribute(); + static const int kAttributeFieldNumber = 1; + inline const ::bgs::protocol::Attribute& attribute(int index) const; + inline ::bgs::protocol::Attribute* mutable_attribute(int index); + inline ::bgs::protocol::Attribute* add_attribute(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& + attribute() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* + mutable_attribute(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.ClientResponse) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_; + friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ClientResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ServerRequest : public ::google::protobuf::Message { + public: + ServerRequest(); + virtual ~ServerRequest(); + + ServerRequest(const ServerRequest& from); + + inline ServerRequest& operator=(const ServerRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ServerRequest& default_instance(); + + void Swap(ServerRequest* other); + + // implements Message ---------------------------------------------- + + ServerRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ServerRequest& from); + void MergeFrom(const ServerRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.Attribute attribute = 1; + inline int attribute_size() const; + inline void clear_attribute(); + static const int kAttributeFieldNumber = 1; + inline const ::bgs::protocol::Attribute& attribute(int index) const; + inline ::bgs::protocol::Attribute* mutable_attribute(int index); + inline ::bgs::protocol::Attribute* add_attribute(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& + attribute() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* + mutable_attribute(); + + // required fixed32 program = 2; + inline bool has_program() const; + inline void clear_program(); + static const int kProgramFieldNumber = 2; + inline ::google::protobuf::uint32 program() const; + inline void set_program(::google::protobuf::uint32 value); + + // optional .bgs.protocol.ProcessId host = 3; + inline bool has_host() const; + inline void clear_host(); + static const int kHostFieldNumber = 3; + inline const ::bgs::protocol::ProcessId& host() const; + inline ::bgs::protocol::ProcessId* mutable_host(); + inline ::bgs::protocol::ProcessId* release_host(); + inline void set_allocated_host(::bgs::protocol::ProcessId* host); + + // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.ServerRequest) + private: + inline void set_has_program(); + inline void clear_has_program(); + inline void set_has_host(); + inline void clear_has_host(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_; + ::bgs::protocol::ProcessId* host_; + ::google::protobuf::uint32 program_; + friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ServerRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ServerResponse : public ::google::protobuf::Message { + public: + ServerResponse(); + virtual ~ServerResponse(); + + ServerResponse(const ServerResponse& from); + + inline ServerResponse& operator=(const ServerResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ServerResponse& default_instance(); + + void Swap(ServerResponse* other); + + // implements Message ---------------------------------------------- + + ServerResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ServerResponse& from); + void MergeFrom(const ServerResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.Attribute attribute = 1; + inline int attribute_size() const; + inline void clear_attribute(); + static const int kAttributeFieldNumber = 1; + inline const ::bgs::protocol::Attribute& attribute(int index) const; + inline ::bgs::protocol::Attribute* mutable_attribute(int index); + inline ::bgs::protocol::Attribute* add_attribute(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& + attribute() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* + mutable_attribute(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.ServerResponse) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_; + friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ServerResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API PresenceChannelCreatedRequest : public ::google::protobuf::Message { + public: + PresenceChannelCreatedRequest(); + virtual ~PresenceChannelCreatedRequest(); + + PresenceChannelCreatedRequest(const PresenceChannelCreatedRequest& from); + + inline PresenceChannelCreatedRequest& operator=(const PresenceChannelCreatedRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const PresenceChannelCreatedRequest& default_instance(); + + void Swap(PresenceChannelCreatedRequest* other); + + // implements Message ---------------------------------------------- + + PresenceChannelCreatedRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const PresenceChannelCreatedRequest& from); + void MergeFrom(const PresenceChannelCreatedRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.EntityId id = 1; + inline bool has_id() const; + inline void clear_id(); + static const int kIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& id() const; + inline ::bgs::protocol::EntityId* mutable_id(); + inline ::bgs::protocol::EntityId* release_id(); + inline void set_allocated_id(::bgs::protocol::EntityId* id); + + // optional .bgs.protocol.EntityId game_account_id = 3; + inline bool has_game_account_id() const; + inline void clear_game_account_id(); + static const int kGameAccountIdFieldNumber = 3; + inline const ::bgs::protocol::EntityId& game_account_id() const; + inline ::bgs::protocol::EntityId* mutable_game_account_id(); + inline ::bgs::protocol::EntityId* release_game_account_id(); + inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id); + + // optional .bgs.protocol.EntityId account_id = 4; + inline bool has_account_id() const; + inline void clear_account_id(); + static const int kAccountIdFieldNumber = 4; + inline const ::bgs::protocol::EntityId& account_id() const; + inline ::bgs::protocol::EntityId* mutable_account_id(); + inline ::bgs::protocol::EntityId* release_account_id(); + inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id); + + // optional .bgs.protocol.ProcessId host = 5; + inline bool has_host() const; + inline void clear_host(); + static const int kHostFieldNumber = 5; + inline const ::bgs::protocol::ProcessId& host() const; + inline ::bgs::protocol::ProcessId* mutable_host(); + inline ::bgs::protocol::ProcessId* release_host(); + inline void set_allocated_host(::bgs::protocol::ProcessId* host); + + // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest) + private: + inline void set_has_id(); + inline void clear_has_id(); + inline void set_has_game_account_id(); + inline void clear_has_game_account_id(); + inline void set_has_account_id(); + inline void clear_has_account_id(); + inline void set_has_host(); + inline void clear_has_host(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* id_; + ::bgs::protocol::EntityId* game_account_id_; + ::bgs::protocol::EntityId* account_id_; + ::bgs::protocol::ProcessId* host_; + friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static PresenceChannelCreatedRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GetPlayerVariablesRequest : public ::google::protobuf::Message { + public: + GetPlayerVariablesRequest(); + virtual ~GetPlayerVariablesRequest(); + + GetPlayerVariablesRequest(const GetPlayerVariablesRequest& from); + + inline GetPlayerVariablesRequest& operator=(const GetPlayerVariablesRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GetPlayerVariablesRequest& default_instance(); + + void Swap(GetPlayerVariablesRequest* other); + + // implements Message ---------------------------------------------- + + GetPlayerVariablesRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GetPlayerVariablesRequest& from); + void MergeFrom(const GetPlayerVariablesRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.game_utilities.v1.PlayerVariables player_variables = 1; + inline int player_variables_size() const; + inline void clear_player_variables(); + static const int kPlayerVariablesFieldNumber = 1; + inline const ::bgs::protocol::game_utilities::v1::PlayerVariables& player_variables(int index) const; + inline ::bgs::protocol::game_utilities::v1::PlayerVariables* mutable_player_variables(int index); + inline ::bgs::protocol::game_utilities::v1::PlayerVariables* add_player_variables(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::game_utilities::v1::PlayerVariables >& + player_variables() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::game_utilities::v1::PlayerVariables >* + mutable_player_variables(); + + // optional .bgs.protocol.ProcessId host = 2; + inline bool has_host() const; + inline void clear_host(); + static const int kHostFieldNumber = 2; + inline const ::bgs::protocol::ProcessId& host() const; + inline ::bgs::protocol::ProcessId* mutable_host(); + inline ::bgs::protocol::ProcessId* release_host(); + inline void set_allocated_host(::bgs::protocol::ProcessId* host); + + // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest) + private: + inline void set_has_host(); + inline void clear_has_host(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::game_utilities::v1::PlayerVariables > player_variables_; + ::bgs::protocol::ProcessId* host_; + friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GetPlayerVariablesRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GetPlayerVariablesResponse : public ::google::protobuf::Message { + public: + GetPlayerVariablesResponse(); + virtual ~GetPlayerVariablesResponse(); + + GetPlayerVariablesResponse(const GetPlayerVariablesResponse& from); + + inline GetPlayerVariablesResponse& operator=(const GetPlayerVariablesResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GetPlayerVariablesResponse& default_instance(); + + void Swap(GetPlayerVariablesResponse* other); + + // implements Message ---------------------------------------------- + + GetPlayerVariablesResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GetPlayerVariablesResponse& from); + void MergeFrom(const GetPlayerVariablesResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.game_utilities.v1.PlayerVariables player_variables = 1; + inline int player_variables_size() const; + inline void clear_player_variables(); + static const int kPlayerVariablesFieldNumber = 1; + inline const ::bgs::protocol::game_utilities::v1::PlayerVariables& player_variables(int index) const; + inline ::bgs::protocol::game_utilities::v1::PlayerVariables* mutable_player_variables(int index); + inline ::bgs::protocol::game_utilities::v1::PlayerVariables* add_player_variables(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::game_utilities::v1::PlayerVariables >& + player_variables() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::game_utilities::v1::PlayerVariables >* + mutable_player_variables(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::game_utilities::v1::PlayerVariables > player_variables_; + friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GetPlayerVariablesResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GameAccountOnlineNotification : public ::google::protobuf::Message { + public: + GameAccountOnlineNotification(); + virtual ~GameAccountOnlineNotification(); + + GameAccountOnlineNotification(const GameAccountOnlineNotification& from); + + inline GameAccountOnlineNotification& operator=(const GameAccountOnlineNotification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GameAccountOnlineNotification& default_instance(); + + void Swap(GameAccountOnlineNotification* other); + + // implements Message ---------------------------------------------- + + GameAccountOnlineNotification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GameAccountOnlineNotification& from); + void MergeFrom(const GameAccountOnlineNotification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.EntityId game_account_id = 1; + inline bool has_game_account_id() const; + inline void clear_game_account_id(); + static const int kGameAccountIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& game_account_id() const; + inline ::bgs::protocol::EntityId* mutable_game_account_id(); + inline ::bgs::protocol::EntityId* release_game_account_id(); + inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id); + + // optional .bgs.protocol.ProcessId host = 2; + inline bool has_host() const; + inline void clear_host(); + static const int kHostFieldNumber = 2; + inline const ::bgs::protocol::ProcessId& host() const; + inline ::bgs::protocol::ProcessId* mutable_host(); + inline ::bgs::protocol::ProcessId* release_host(); + inline void set_allocated_host(::bgs::protocol::ProcessId* host); + + // optional string session_id = 3; + inline bool has_session_id() const; + inline void clear_session_id(); + static const int kSessionIdFieldNumber = 3; + inline const ::std::string& session_id() const; + inline void set_session_id(const ::std::string& value); + inline void set_session_id(const char* value); + inline void set_session_id(const char* value, size_t size); + inline ::std::string* mutable_session_id(); + inline ::std::string* release_session_id(); + inline void set_allocated_session_id(::std::string* session_id); + + // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification) + private: + inline void set_has_game_account_id(); + inline void clear_has_game_account_id(); + inline void set_has_host(); + inline void clear_has_host(); + inline void set_has_session_id(); + inline void clear_has_session_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* game_account_id_; + ::bgs::protocol::ProcessId* host_; + ::std::string* session_id_; + friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GameAccountOnlineNotification* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GameAccountOfflineNotification : public ::google::protobuf::Message { + public: + GameAccountOfflineNotification(); + virtual ~GameAccountOfflineNotification(); + + GameAccountOfflineNotification(const GameAccountOfflineNotification& from); + + inline GameAccountOfflineNotification& operator=(const GameAccountOfflineNotification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GameAccountOfflineNotification& default_instance(); + + void Swap(GameAccountOfflineNotification* other); + + // implements Message ---------------------------------------------- + + GameAccountOfflineNotification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GameAccountOfflineNotification& from); + void MergeFrom(const GameAccountOfflineNotification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.EntityId game_account_id = 1; + inline bool has_game_account_id() const; + inline void clear_game_account_id(); + static const int kGameAccountIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& game_account_id() const; + inline ::bgs::protocol::EntityId* mutable_game_account_id(); + inline ::bgs::protocol::EntityId* release_game_account_id(); + inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id); + + // optional .bgs.protocol.ProcessId host = 2; + inline bool has_host() const; + inline void clear_host(); + static const int kHostFieldNumber = 2; + inline const ::bgs::protocol::ProcessId& host() const; + inline ::bgs::protocol::ProcessId* mutable_host(); + inline ::bgs::protocol::ProcessId* release_host(); + inline void set_allocated_host(::bgs::protocol::ProcessId* host); + + // optional string session_id = 3; + inline bool has_session_id() const; + inline void clear_session_id(); + static const int kSessionIdFieldNumber = 3; + inline const ::std::string& session_id() const; + inline void set_session_id(const ::std::string& value); + inline void set_session_id(const char* value); + inline void set_session_id(const char* value, size_t size); + inline ::std::string* mutable_session_id(); + inline ::std::string* release_session_id(); + inline void set_allocated_session_id(::std::string* session_id); + + // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification) + private: + inline void set_has_game_account_id(); + inline void clear_has_game_account_id(); + inline void set_has_host(); + inline void clear_has_host(); + inline void set_has_session_id(); + inline void clear_has_session_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* game_account_id_; + ::bgs::protocol::ProcessId* host_; + ::std::string* session_id_; + friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GameAccountOfflineNotification* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GetAchievementsFileRequest : public ::google::protobuf::Message { + public: + GetAchievementsFileRequest(); + virtual ~GetAchievementsFileRequest(); + + GetAchievementsFileRequest(const GetAchievementsFileRequest& from); + + inline GetAchievementsFileRequest& operator=(const GetAchievementsFileRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GetAchievementsFileRequest& default_instance(); + + void Swap(GetAchievementsFileRequest* other); + + // implements Message ---------------------------------------------- + + GetAchievementsFileRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GetAchievementsFileRequest& from); + void MergeFrom(const GetAchievementsFileRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.ProcessId host = 1; + inline bool has_host() const; + inline void clear_host(); + static const int kHostFieldNumber = 1; + inline const ::bgs::protocol::ProcessId& host() const; + inline ::bgs::protocol::ProcessId* mutable_host(); + inline ::bgs::protocol::ProcessId* release_host(); + inline void set_allocated_host(::bgs::protocol::ProcessId* host); + + // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest) + private: + inline void set_has_host(); + inline void clear_has_host(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::ProcessId* host_; + friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GetAchievementsFileRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GetAchievementsFileResponse : public ::google::protobuf::Message { + public: + GetAchievementsFileResponse(); + virtual ~GetAchievementsFileResponse(); + + GetAchievementsFileResponse(const GetAchievementsFileResponse& from); + + inline GetAchievementsFileResponse& operator=(const GetAchievementsFileResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GetAchievementsFileResponse& default_instance(); + + void Swap(GetAchievementsFileResponse* other); + + // implements Message ---------------------------------------------- + + GetAchievementsFileResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GetAchievementsFileResponse& from); + void MergeFrom(const GetAchievementsFileResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.ContentHandle content_handle = 1; + inline bool has_content_handle() const; + inline void clear_content_handle(); + static const int kContentHandleFieldNumber = 1; + inline const ::bgs::protocol::ContentHandle& content_handle() const; + inline ::bgs::protocol::ContentHandle* mutable_content_handle(); + inline ::bgs::protocol::ContentHandle* release_content_handle(); + inline void set_allocated_content_handle(::bgs::protocol::ContentHandle* content_handle); + + // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse) + private: + inline void set_has_content_handle(); + inline void clear_has_content_handle(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::ContentHandle* content_handle_; + friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GetAchievementsFileResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GetAllValuesForAttributeRequest : public ::google::protobuf::Message { + public: + GetAllValuesForAttributeRequest(); + virtual ~GetAllValuesForAttributeRequest(); + + GetAllValuesForAttributeRequest(const GetAllValuesForAttributeRequest& from); + + inline GetAllValuesForAttributeRequest& operator=(const GetAllValuesForAttributeRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GetAllValuesForAttributeRequest& default_instance(); + + void Swap(GetAllValuesForAttributeRequest* other); + + // implements Message ---------------------------------------------- + + GetAllValuesForAttributeRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GetAllValuesForAttributeRequest& from); + void MergeFrom(const GetAllValuesForAttributeRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string attribute_key = 1; + inline bool has_attribute_key() const; + inline void clear_attribute_key(); + static const int kAttributeKeyFieldNumber = 1; + inline const ::std::string& attribute_key() const; + inline void set_attribute_key(const ::std::string& value); + inline void set_attribute_key(const char* value); + inline void set_attribute_key(const char* value, size_t size); + inline ::std::string* mutable_attribute_key(); + inline ::std::string* release_attribute_key(); + inline void set_allocated_attribute_key(::std::string* attribute_key); + + // optional .bgs.protocol.EntityId agent_id = 2; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // optional fixed32 program = 5; + inline bool has_program() const; + inline void clear_program(); + static const int kProgramFieldNumber = 5; + inline ::google::protobuf::uint32 program() const; + inline void set_program(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest) + private: + inline void set_has_attribute_key(); + inline void clear_has_attribute_key(); + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_program(); + inline void clear_has_program(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* attribute_key_; + ::bgs::protocol::EntityId* agent_id_; + ::google::protobuf::uint32 program_; + friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GetAllValuesForAttributeRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GetAllValuesForAttributeResponse : public ::google::protobuf::Message { + public: + GetAllValuesForAttributeResponse(); + virtual ~GetAllValuesForAttributeResponse(); + + GetAllValuesForAttributeResponse(const GetAllValuesForAttributeResponse& from); + + inline GetAllValuesForAttributeResponse& operator=(const GetAllValuesForAttributeResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GetAllValuesForAttributeResponse& default_instance(); + + void Swap(GetAllValuesForAttributeResponse* other); + + // implements Message ---------------------------------------------- + + GetAllValuesForAttributeResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GetAllValuesForAttributeResponse& from); + void MergeFrom(const GetAllValuesForAttributeResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.Variant attribute_value = 1; + inline int attribute_value_size() const; + inline void clear_attribute_value(); + static const int kAttributeValueFieldNumber = 1; + inline const ::bgs::protocol::Variant& attribute_value(int index) const; + inline ::bgs::protocol::Variant* mutable_attribute_value(int index); + inline ::bgs::protocol::Variant* add_attribute_value(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Variant >& + attribute_value() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Variant >* + mutable_attribute_value(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Variant > attribute_value_; + friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto(); + friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static GetAllValuesForAttributeResponse* default_instance_; +}; +// =================================================================== + +class TC_SHARED_API GameUtilitiesService : public ServiceBase +{ + public: + + template + explicit GameUtilitiesService(HashSelector) : service_hash_(HashSelector::Result::value) { } + + typedef std::integral_constant OriginalHash; + typedef std::integral_constant NameHash; + + static google::protobuf::ServiceDescriptor const* descriptor(); + + // client methods -------------------------------------------------- + + void ProcessClientRequest(::bgs::protocol::game_utilities::v1::ClientRequest const* request, std::function responseCallback); + void PresenceChannelCreated(::bgs::protocol::game_utilities::v1::PresenceChannelCreatedRequest const* request, std::function responseCallback); + void GetPlayerVariables(::bgs::protocol::game_utilities::v1::GetPlayerVariablesRequest const* request, std::function responseCallback); + void ProcessServerRequest(::bgs::protocol::game_utilities::v1::ServerRequest const* request, std::function responseCallback); + void OnGameAccountOnline(::bgs::protocol::game_utilities::v1::GameAccountOnlineNotification const* request); + void OnGameAccountOffline(::bgs::protocol::game_utilities::v1::GameAccountOfflineNotification const* request); + void GetAchievementsFile(::bgs::protocol::game_utilities::v1::GetAchievementsFileRequest const* request, std::function responseCallback); + void GetAllValuesForAttribute(::bgs::protocol::game_utilities::v1::GetAllValuesForAttributeRequest const* request, std::function responseCallback); + // server methods -------------------------------------------------- + + void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final; + + protected: + virtual uint32 HandleProcessClientRequest(::bgs::protocol::game_utilities::v1::ClientRequest const* request, ::bgs::protocol::game_utilities::v1::ClientResponse* response); + virtual uint32 HandlePresenceChannelCreated(::bgs::protocol::game_utilities::v1::PresenceChannelCreatedRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleGetPlayerVariables(::bgs::protocol::game_utilities::v1::GetPlayerVariablesRequest const* request, ::bgs::protocol::game_utilities::v1::GetPlayerVariablesResponse* response); + virtual uint32 HandleProcessServerRequest(::bgs::protocol::game_utilities::v1::ServerRequest const* request, ::bgs::protocol::game_utilities::v1::ServerResponse* response); + virtual uint32 HandleOnGameAccountOnline(::bgs::protocol::game_utilities::v1::GameAccountOnlineNotification const* request); + virtual uint32 HandleOnGameAccountOffline(::bgs::protocol::game_utilities::v1::GameAccountOfflineNotification const* request); + virtual uint32 HandleGetAchievementsFile(::bgs::protocol::game_utilities::v1::GetAchievementsFileRequest const* request, ::bgs::protocol::game_utilities::v1::GetAchievementsFileResponse* response); + virtual uint32 HandleGetAllValuesForAttribute(::bgs::protocol::game_utilities::v1::GetAllValuesForAttributeRequest const* request, ::bgs::protocol::game_utilities::v1::GetAllValuesForAttributeResponse* response); + + private: + uint32 service_hash_; + + GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GameUtilitiesService); +}; + +// =================================================================== + + +// =================================================================== + +// ClientRequest + +// repeated .bgs.protocol.Attribute attribute = 1; +inline int ClientRequest::attribute_size() const { + return attribute_.size(); +} +inline void ClientRequest::clear_attribute() { + attribute_.Clear(); +} +inline const ::bgs::protocol::Attribute& ClientRequest::attribute(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ClientRequest.attribute) + return attribute_.Get(index); +} +inline ::bgs::protocol::Attribute* ClientRequest::mutable_attribute(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.ClientRequest.attribute) + return attribute_.Mutable(index); +} +inline ::bgs::protocol::Attribute* ClientRequest::add_attribute() { + // @@protoc_insertion_point(field_add:bgs.protocol.game_utilities.v1.ClientRequest.attribute) + return attribute_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& +ClientRequest::attribute() const { + // @@protoc_insertion_point(field_list:bgs.protocol.game_utilities.v1.ClientRequest.attribute) + return attribute_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* +ClientRequest::mutable_attribute() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.game_utilities.v1.ClientRequest.attribute) + return &attribute_; +} + +// optional .bgs.protocol.ProcessId host = 2; +inline bool ClientRequest::has_host() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ClientRequest::set_has_host() { + _has_bits_[0] |= 0x00000002u; +} +inline void ClientRequest::clear_has_host() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ClientRequest::clear_host() { + if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear(); + clear_has_host(); +} +inline const ::bgs::protocol::ProcessId& ClientRequest::host() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ClientRequest.host) + return host_ != NULL ? *host_ : *default_instance_->host_; +} +inline ::bgs::protocol::ProcessId* ClientRequest::mutable_host() { + set_has_host(); + if (host_ == NULL) host_ = new ::bgs::protocol::ProcessId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.ClientRequest.host) + return host_; +} +inline ::bgs::protocol::ProcessId* ClientRequest::release_host() { + clear_has_host(); + ::bgs::protocol::ProcessId* temp = host_; + host_ = NULL; + return temp; +} +inline void ClientRequest::set_allocated_host(::bgs::protocol::ProcessId* host) { + delete host_; + host_ = host; + if (host) { + set_has_host(); + } else { + clear_has_host(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.ClientRequest.host) +} + +// optional .bgs.protocol.EntityId account_id = 3; +inline bool ClientRequest::has_account_id() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ClientRequest::set_has_account_id() { + _has_bits_[0] |= 0x00000004u; +} +inline void ClientRequest::clear_has_account_id() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ClientRequest::clear_account_id() { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_account_id(); +} +inline const ::bgs::protocol::EntityId& ClientRequest::account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ClientRequest.account_id) + return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_; +} +inline ::bgs::protocol::EntityId* ClientRequest::mutable_account_id() { + set_has_account_id(); + if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.ClientRequest.account_id) + return account_id_; +} +inline ::bgs::protocol::EntityId* ClientRequest::release_account_id() { + clear_has_account_id(); + ::bgs::protocol::EntityId* temp = account_id_; + account_id_ = NULL; + return temp; +} +inline void ClientRequest::set_allocated_account_id(::bgs::protocol::EntityId* account_id) { + delete account_id_; + account_id_ = account_id; + if (account_id) { + set_has_account_id(); + } else { + clear_has_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.ClientRequest.account_id) +} + +// optional .bgs.protocol.EntityId game_account_id = 4; +inline bool ClientRequest::has_game_account_id() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void ClientRequest::set_has_game_account_id() { + _has_bits_[0] |= 0x00000008u; +} +inline void ClientRequest::clear_has_game_account_id() { + _has_bits_[0] &= ~0x00000008u; +} +inline void ClientRequest::clear_game_account_id() { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_game_account_id(); +} +inline const ::bgs::protocol::EntityId& ClientRequest::game_account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ClientRequest.game_account_id) + return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_; +} +inline ::bgs::protocol::EntityId* ClientRequest::mutable_game_account_id() { + set_has_game_account_id(); + if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.ClientRequest.game_account_id) + return game_account_id_; +} +inline ::bgs::protocol::EntityId* ClientRequest::release_game_account_id() { + clear_has_game_account_id(); + ::bgs::protocol::EntityId* temp = game_account_id_; + game_account_id_ = NULL; + return temp; +} +inline void ClientRequest::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) { + delete game_account_id_; + game_account_id_ = game_account_id; + if (game_account_id) { + set_has_game_account_id(); + } else { + clear_has_game_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.ClientRequest.game_account_id) +} + +// optional fixed32 program = 5; +inline bool ClientRequest::has_program() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void ClientRequest::set_has_program() { + _has_bits_[0] |= 0x00000010u; +} +inline void ClientRequest::clear_has_program() { + _has_bits_[0] &= ~0x00000010u; +} +inline void ClientRequest::clear_program() { + program_ = 0u; + clear_has_program(); +} +inline ::google::protobuf::uint32 ClientRequest::program() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ClientRequest.program) + return program_; +} +inline void ClientRequest::set_program(::google::protobuf::uint32 value) { + set_has_program(); + program_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.game_utilities.v1.ClientRequest.program) +} + +// optional .bgs.protocol.game_utilities.v1.ClientInfo client_info = 6; +inline bool ClientRequest::has_client_info() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void ClientRequest::set_has_client_info() { + _has_bits_[0] |= 0x00000020u; +} +inline void ClientRequest::clear_has_client_info() { + _has_bits_[0] &= ~0x00000020u; +} +inline void ClientRequest::clear_client_info() { + if (client_info_ != NULL) client_info_->::bgs::protocol::game_utilities::v1::ClientInfo::Clear(); + clear_has_client_info(); +} +inline const ::bgs::protocol::game_utilities::v1::ClientInfo& ClientRequest::client_info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ClientRequest.client_info) + return client_info_ != NULL ? *client_info_ : *default_instance_->client_info_; +} +inline ::bgs::protocol::game_utilities::v1::ClientInfo* ClientRequest::mutable_client_info() { + set_has_client_info(); + if (client_info_ == NULL) client_info_ = new ::bgs::protocol::game_utilities::v1::ClientInfo; + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.ClientRequest.client_info) + return client_info_; +} +inline ::bgs::protocol::game_utilities::v1::ClientInfo* ClientRequest::release_client_info() { + clear_has_client_info(); + ::bgs::protocol::game_utilities::v1::ClientInfo* temp = client_info_; + client_info_ = NULL; + return temp; +} +inline void ClientRequest::set_allocated_client_info(::bgs::protocol::game_utilities::v1::ClientInfo* client_info) { + delete client_info_; + client_info_ = client_info; + if (client_info) { + set_has_client_info(); + } else { + clear_has_client_info(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.ClientRequest.client_info) +} + +// ------------------------------------------------------------------- + +// ClientResponse + +// repeated .bgs.protocol.Attribute attribute = 1; +inline int ClientResponse::attribute_size() const { + return attribute_.size(); +} +inline void ClientResponse::clear_attribute() { + attribute_.Clear(); +} +inline const ::bgs::protocol::Attribute& ClientResponse::attribute(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ClientResponse.attribute) + return attribute_.Get(index); +} +inline ::bgs::protocol::Attribute* ClientResponse::mutable_attribute(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.ClientResponse.attribute) + return attribute_.Mutable(index); +} +inline ::bgs::protocol::Attribute* ClientResponse::add_attribute() { + // @@protoc_insertion_point(field_add:bgs.protocol.game_utilities.v1.ClientResponse.attribute) + return attribute_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& +ClientResponse::attribute() const { + // @@protoc_insertion_point(field_list:bgs.protocol.game_utilities.v1.ClientResponse.attribute) + return attribute_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* +ClientResponse::mutable_attribute() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.game_utilities.v1.ClientResponse.attribute) + return &attribute_; +} + +// ------------------------------------------------------------------- + +// ServerRequest + +// repeated .bgs.protocol.Attribute attribute = 1; +inline int ServerRequest::attribute_size() const { + return attribute_.size(); +} +inline void ServerRequest::clear_attribute() { + attribute_.Clear(); +} +inline const ::bgs::protocol::Attribute& ServerRequest::attribute(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ServerRequest.attribute) + return attribute_.Get(index); +} +inline ::bgs::protocol::Attribute* ServerRequest::mutable_attribute(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.ServerRequest.attribute) + return attribute_.Mutable(index); +} +inline ::bgs::protocol::Attribute* ServerRequest::add_attribute() { + // @@protoc_insertion_point(field_add:bgs.protocol.game_utilities.v1.ServerRequest.attribute) + return attribute_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& +ServerRequest::attribute() const { + // @@protoc_insertion_point(field_list:bgs.protocol.game_utilities.v1.ServerRequest.attribute) + return attribute_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* +ServerRequest::mutable_attribute() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.game_utilities.v1.ServerRequest.attribute) + return &attribute_; +} + +// required fixed32 program = 2; +inline bool ServerRequest::has_program() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ServerRequest::set_has_program() { + _has_bits_[0] |= 0x00000002u; +} +inline void ServerRequest::clear_has_program() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ServerRequest::clear_program() { + program_ = 0u; + clear_has_program(); +} +inline ::google::protobuf::uint32 ServerRequest::program() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ServerRequest.program) + return program_; +} +inline void ServerRequest::set_program(::google::protobuf::uint32 value) { + set_has_program(); + program_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.game_utilities.v1.ServerRequest.program) +} + +// optional .bgs.protocol.ProcessId host = 3; +inline bool ServerRequest::has_host() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ServerRequest::set_has_host() { + _has_bits_[0] |= 0x00000004u; +} +inline void ServerRequest::clear_has_host() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ServerRequest::clear_host() { + if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear(); + clear_has_host(); +} +inline const ::bgs::protocol::ProcessId& ServerRequest::host() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ServerRequest.host) + return host_ != NULL ? *host_ : *default_instance_->host_; +} +inline ::bgs::protocol::ProcessId* ServerRequest::mutable_host() { + set_has_host(); + if (host_ == NULL) host_ = new ::bgs::protocol::ProcessId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.ServerRequest.host) + return host_; +} +inline ::bgs::protocol::ProcessId* ServerRequest::release_host() { + clear_has_host(); + ::bgs::protocol::ProcessId* temp = host_; + host_ = NULL; + return temp; +} +inline void ServerRequest::set_allocated_host(::bgs::protocol::ProcessId* host) { + delete host_; + host_ = host; + if (host) { + set_has_host(); + } else { + clear_has_host(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.ServerRequest.host) +} + +// ------------------------------------------------------------------- + +// ServerResponse + +// repeated .bgs.protocol.Attribute attribute = 1; +inline int ServerResponse::attribute_size() const { + return attribute_.size(); +} +inline void ServerResponse::clear_attribute() { + attribute_.Clear(); +} +inline const ::bgs::protocol::Attribute& ServerResponse::attribute(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ServerResponse.attribute) + return attribute_.Get(index); +} +inline ::bgs::protocol::Attribute* ServerResponse::mutable_attribute(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.ServerResponse.attribute) + return attribute_.Mutable(index); +} +inline ::bgs::protocol::Attribute* ServerResponse::add_attribute() { + // @@protoc_insertion_point(field_add:bgs.protocol.game_utilities.v1.ServerResponse.attribute) + return attribute_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& +ServerResponse::attribute() const { + // @@protoc_insertion_point(field_list:bgs.protocol.game_utilities.v1.ServerResponse.attribute) + return attribute_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* +ServerResponse::mutable_attribute() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.game_utilities.v1.ServerResponse.attribute) + return &attribute_; +} + +// ------------------------------------------------------------------- + +// PresenceChannelCreatedRequest + +// required .bgs.protocol.EntityId id = 1; +inline bool PresenceChannelCreatedRequest::has_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void PresenceChannelCreatedRequest::set_has_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void PresenceChannelCreatedRequest::clear_has_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void PresenceChannelCreatedRequest::clear_id() { + if (id_ != NULL) id_->::bgs::protocol::EntityId::Clear(); + clear_has_id(); +} +inline const ::bgs::protocol::EntityId& PresenceChannelCreatedRequest::id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest.id) + return id_ != NULL ? *id_ : *default_instance_->id_; +} +inline ::bgs::protocol::EntityId* PresenceChannelCreatedRequest::mutable_id() { + set_has_id(); + if (id_ == NULL) id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest.id) + return id_; +} +inline ::bgs::protocol::EntityId* PresenceChannelCreatedRequest::release_id() { + clear_has_id(); + ::bgs::protocol::EntityId* temp = id_; + id_ = NULL; + return temp; +} +inline void PresenceChannelCreatedRequest::set_allocated_id(::bgs::protocol::EntityId* id) { + delete id_; + id_ = id; + if (id) { + set_has_id(); + } else { + clear_has_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest.id) +} + +// optional .bgs.protocol.EntityId game_account_id = 3; +inline bool PresenceChannelCreatedRequest::has_game_account_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void PresenceChannelCreatedRequest::set_has_game_account_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void PresenceChannelCreatedRequest::clear_has_game_account_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void PresenceChannelCreatedRequest::clear_game_account_id() { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_game_account_id(); +} +inline const ::bgs::protocol::EntityId& PresenceChannelCreatedRequest::game_account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest.game_account_id) + return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_; +} +inline ::bgs::protocol::EntityId* PresenceChannelCreatedRequest::mutable_game_account_id() { + set_has_game_account_id(); + if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest.game_account_id) + return game_account_id_; +} +inline ::bgs::protocol::EntityId* PresenceChannelCreatedRequest::release_game_account_id() { + clear_has_game_account_id(); + ::bgs::protocol::EntityId* temp = game_account_id_; + game_account_id_ = NULL; + return temp; +} +inline void PresenceChannelCreatedRequest::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) { + delete game_account_id_; + game_account_id_ = game_account_id; + if (game_account_id) { + set_has_game_account_id(); + } else { + clear_has_game_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest.game_account_id) +} + +// optional .bgs.protocol.EntityId account_id = 4; +inline bool PresenceChannelCreatedRequest::has_account_id() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void PresenceChannelCreatedRequest::set_has_account_id() { + _has_bits_[0] |= 0x00000004u; +} +inline void PresenceChannelCreatedRequest::clear_has_account_id() { + _has_bits_[0] &= ~0x00000004u; +} +inline void PresenceChannelCreatedRequest::clear_account_id() { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_account_id(); +} +inline const ::bgs::protocol::EntityId& PresenceChannelCreatedRequest::account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest.account_id) + return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_; +} +inline ::bgs::protocol::EntityId* PresenceChannelCreatedRequest::mutable_account_id() { + set_has_account_id(); + if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest.account_id) + return account_id_; +} +inline ::bgs::protocol::EntityId* PresenceChannelCreatedRequest::release_account_id() { + clear_has_account_id(); + ::bgs::protocol::EntityId* temp = account_id_; + account_id_ = NULL; + return temp; +} +inline void PresenceChannelCreatedRequest::set_allocated_account_id(::bgs::protocol::EntityId* account_id) { + delete account_id_; + account_id_ = account_id; + if (account_id) { + set_has_account_id(); + } else { + clear_has_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest.account_id) +} + +// optional .bgs.protocol.ProcessId host = 5; +inline bool PresenceChannelCreatedRequest::has_host() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void PresenceChannelCreatedRequest::set_has_host() { + _has_bits_[0] |= 0x00000008u; +} +inline void PresenceChannelCreatedRequest::clear_has_host() { + _has_bits_[0] &= ~0x00000008u; +} +inline void PresenceChannelCreatedRequest::clear_host() { + if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear(); + clear_has_host(); +} +inline const ::bgs::protocol::ProcessId& PresenceChannelCreatedRequest::host() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest.host) + return host_ != NULL ? *host_ : *default_instance_->host_; +} +inline ::bgs::protocol::ProcessId* PresenceChannelCreatedRequest::mutable_host() { + set_has_host(); + if (host_ == NULL) host_ = new ::bgs::protocol::ProcessId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest.host) + return host_; +} +inline ::bgs::protocol::ProcessId* PresenceChannelCreatedRequest::release_host() { + clear_has_host(); + ::bgs::protocol::ProcessId* temp = host_; + host_ = NULL; + return temp; +} +inline void PresenceChannelCreatedRequest::set_allocated_host(::bgs::protocol::ProcessId* host) { + delete host_; + host_ = host; + if (host) { + set_has_host(); + } else { + clear_has_host(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest.host) +} + +// ------------------------------------------------------------------- + +// GetPlayerVariablesRequest + +// repeated .bgs.protocol.game_utilities.v1.PlayerVariables player_variables = 1; +inline int GetPlayerVariablesRequest::player_variables_size() const { + return player_variables_.size(); +} +inline void GetPlayerVariablesRequest::clear_player_variables() { + player_variables_.Clear(); +} +inline const ::bgs::protocol::game_utilities::v1::PlayerVariables& GetPlayerVariablesRequest::player_variables(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest.player_variables) + return player_variables_.Get(index); +} +inline ::bgs::protocol::game_utilities::v1::PlayerVariables* GetPlayerVariablesRequest::mutable_player_variables(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest.player_variables) + return player_variables_.Mutable(index); +} +inline ::bgs::protocol::game_utilities::v1::PlayerVariables* GetPlayerVariablesRequest::add_player_variables() { + // @@protoc_insertion_point(field_add:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest.player_variables) + return player_variables_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::game_utilities::v1::PlayerVariables >& +GetPlayerVariablesRequest::player_variables() const { + // @@protoc_insertion_point(field_list:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest.player_variables) + return player_variables_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::game_utilities::v1::PlayerVariables >* +GetPlayerVariablesRequest::mutable_player_variables() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest.player_variables) + return &player_variables_; +} + +// optional .bgs.protocol.ProcessId host = 2; +inline bool GetPlayerVariablesRequest::has_host() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GetPlayerVariablesRequest::set_has_host() { + _has_bits_[0] |= 0x00000002u; +} +inline void GetPlayerVariablesRequest::clear_has_host() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GetPlayerVariablesRequest::clear_host() { + if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear(); + clear_has_host(); +} +inline const ::bgs::protocol::ProcessId& GetPlayerVariablesRequest::host() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest.host) + return host_ != NULL ? *host_ : *default_instance_->host_; +} +inline ::bgs::protocol::ProcessId* GetPlayerVariablesRequest::mutable_host() { + set_has_host(); + if (host_ == NULL) host_ = new ::bgs::protocol::ProcessId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest.host) + return host_; +} +inline ::bgs::protocol::ProcessId* GetPlayerVariablesRequest::release_host() { + clear_has_host(); + ::bgs::protocol::ProcessId* temp = host_; + host_ = NULL; + return temp; +} +inline void GetPlayerVariablesRequest::set_allocated_host(::bgs::protocol::ProcessId* host) { + delete host_; + host_ = host; + if (host) { + set_has_host(); + } else { + clear_has_host(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest.host) +} + +// ------------------------------------------------------------------- + +// GetPlayerVariablesResponse + +// repeated .bgs.protocol.game_utilities.v1.PlayerVariables player_variables = 1; +inline int GetPlayerVariablesResponse::player_variables_size() const { + return player_variables_.size(); +} +inline void GetPlayerVariablesResponse::clear_player_variables() { + player_variables_.Clear(); +} +inline const ::bgs::protocol::game_utilities::v1::PlayerVariables& GetPlayerVariablesResponse::player_variables(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse.player_variables) + return player_variables_.Get(index); +} +inline ::bgs::protocol::game_utilities::v1::PlayerVariables* GetPlayerVariablesResponse::mutable_player_variables(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse.player_variables) + return player_variables_.Mutable(index); +} +inline ::bgs::protocol::game_utilities::v1::PlayerVariables* GetPlayerVariablesResponse::add_player_variables() { + // @@protoc_insertion_point(field_add:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse.player_variables) + return player_variables_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::game_utilities::v1::PlayerVariables >& +GetPlayerVariablesResponse::player_variables() const { + // @@protoc_insertion_point(field_list:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse.player_variables) + return player_variables_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::game_utilities::v1::PlayerVariables >* +GetPlayerVariablesResponse::mutable_player_variables() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse.player_variables) + return &player_variables_; +} + +// ------------------------------------------------------------------- + +// GameAccountOnlineNotification + +// required .bgs.protocol.EntityId game_account_id = 1; +inline bool GameAccountOnlineNotification::has_game_account_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GameAccountOnlineNotification::set_has_game_account_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void GameAccountOnlineNotification::clear_has_game_account_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GameAccountOnlineNotification::clear_game_account_id() { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_game_account_id(); +} +inline const ::bgs::protocol::EntityId& GameAccountOnlineNotification::game_account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification.game_account_id) + return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_; +} +inline ::bgs::protocol::EntityId* GameAccountOnlineNotification::mutable_game_account_id() { + set_has_game_account_id(); + if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification.game_account_id) + return game_account_id_; +} +inline ::bgs::protocol::EntityId* GameAccountOnlineNotification::release_game_account_id() { + clear_has_game_account_id(); + ::bgs::protocol::EntityId* temp = game_account_id_; + game_account_id_ = NULL; + return temp; +} +inline void GameAccountOnlineNotification::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) { + delete game_account_id_; + game_account_id_ = game_account_id; + if (game_account_id) { + set_has_game_account_id(); + } else { + clear_has_game_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification.game_account_id) +} + +// optional .bgs.protocol.ProcessId host = 2; +inline bool GameAccountOnlineNotification::has_host() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GameAccountOnlineNotification::set_has_host() { + _has_bits_[0] |= 0x00000002u; +} +inline void GameAccountOnlineNotification::clear_has_host() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GameAccountOnlineNotification::clear_host() { + if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear(); + clear_has_host(); +} +inline const ::bgs::protocol::ProcessId& GameAccountOnlineNotification::host() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification.host) + return host_ != NULL ? *host_ : *default_instance_->host_; +} +inline ::bgs::protocol::ProcessId* GameAccountOnlineNotification::mutable_host() { + set_has_host(); + if (host_ == NULL) host_ = new ::bgs::protocol::ProcessId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification.host) + return host_; +} +inline ::bgs::protocol::ProcessId* GameAccountOnlineNotification::release_host() { + clear_has_host(); + ::bgs::protocol::ProcessId* temp = host_; + host_ = NULL; + return temp; +} +inline void GameAccountOnlineNotification::set_allocated_host(::bgs::protocol::ProcessId* host) { + delete host_; + host_ = host; + if (host) { + set_has_host(); + } else { + clear_has_host(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification.host) +} + +// optional string session_id = 3; +inline bool GameAccountOnlineNotification::has_session_id() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GameAccountOnlineNotification::set_has_session_id() { + _has_bits_[0] |= 0x00000004u; +} +inline void GameAccountOnlineNotification::clear_has_session_id() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GameAccountOnlineNotification::clear_session_id() { + if (session_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + session_id_->clear(); + } + clear_has_session_id(); +} +inline const ::std::string& GameAccountOnlineNotification::session_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification.session_id) + return *session_id_; +} +inline void GameAccountOnlineNotification::set_session_id(const ::std::string& value) { + set_has_session_id(); + if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + session_id_ = new ::std::string; + } + session_id_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification.session_id) +} +inline void GameAccountOnlineNotification::set_session_id(const char* value) { + set_has_session_id(); + if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + session_id_ = new ::std::string; + } + session_id_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification.session_id) +} +inline void GameAccountOnlineNotification::set_session_id(const char* value, size_t size) { + set_has_session_id(); + if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + session_id_ = new ::std::string; + } + session_id_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification.session_id) +} +inline ::std::string* GameAccountOnlineNotification::mutable_session_id() { + set_has_session_id(); + if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + session_id_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification.session_id) + return session_id_; +} +inline ::std::string* GameAccountOnlineNotification::release_session_id() { + clear_has_session_id(); + if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = session_id_; + session_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void GameAccountOnlineNotification::set_allocated_session_id(::std::string* session_id) { + if (session_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete session_id_; + } + if (session_id) { + set_has_session_id(); + session_id_ = session_id; + } else { + clear_has_session_id(); + session_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification.session_id) +} + +// ------------------------------------------------------------------- + +// GameAccountOfflineNotification + +// required .bgs.protocol.EntityId game_account_id = 1; +inline bool GameAccountOfflineNotification::has_game_account_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GameAccountOfflineNotification::set_has_game_account_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void GameAccountOfflineNotification::clear_has_game_account_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GameAccountOfflineNotification::clear_game_account_id() { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_game_account_id(); +} +inline const ::bgs::protocol::EntityId& GameAccountOfflineNotification::game_account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification.game_account_id) + return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_; +} +inline ::bgs::protocol::EntityId* GameAccountOfflineNotification::mutable_game_account_id() { + set_has_game_account_id(); + if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification.game_account_id) + return game_account_id_; +} +inline ::bgs::protocol::EntityId* GameAccountOfflineNotification::release_game_account_id() { + clear_has_game_account_id(); + ::bgs::protocol::EntityId* temp = game_account_id_; + game_account_id_ = NULL; + return temp; +} +inline void GameAccountOfflineNotification::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) { + delete game_account_id_; + game_account_id_ = game_account_id; + if (game_account_id) { + set_has_game_account_id(); + } else { + clear_has_game_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification.game_account_id) +} + +// optional .bgs.protocol.ProcessId host = 2; +inline bool GameAccountOfflineNotification::has_host() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GameAccountOfflineNotification::set_has_host() { + _has_bits_[0] |= 0x00000002u; +} +inline void GameAccountOfflineNotification::clear_has_host() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GameAccountOfflineNotification::clear_host() { + if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear(); + clear_has_host(); +} +inline const ::bgs::protocol::ProcessId& GameAccountOfflineNotification::host() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification.host) + return host_ != NULL ? *host_ : *default_instance_->host_; +} +inline ::bgs::protocol::ProcessId* GameAccountOfflineNotification::mutable_host() { + set_has_host(); + if (host_ == NULL) host_ = new ::bgs::protocol::ProcessId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification.host) + return host_; +} +inline ::bgs::protocol::ProcessId* GameAccountOfflineNotification::release_host() { + clear_has_host(); + ::bgs::protocol::ProcessId* temp = host_; + host_ = NULL; + return temp; +} +inline void GameAccountOfflineNotification::set_allocated_host(::bgs::protocol::ProcessId* host) { + delete host_; + host_ = host; + if (host) { + set_has_host(); + } else { + clear_has_host(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification.host) +} + +// optional string session_id = 3; +inline bool GameAccountOfflineNotification::has_session_id() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GameAccountOfflineNotification::set_has_session_id() { + _has_bits_[0] |= 0x00000004u; +} +inline void GameAccountOfflineNotification::clear_has_session_id() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GameAccountOfflineNotification::clear_session_id() { + if (session_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + session_id_->clear(); + } + clear_has_session_id(); +} +inline const ::std::string& GameAccountOfflineNotification::session_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification.session_id) + return *session_id_; +} +inline void GameAccountOfflineNotification::set_session_id(const ::std::string& value) { + set_has_session_id(); + if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + session_id_ = new ::std::string; + } + session_id_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification.session_id) +} +inline void GameAccountOfflineNotification::set_session_id(const char* value) { + set_has_session_id(); + if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + session_id_ = new ::std::string; + } + session_id_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification.session_id) +} +inline void GameAccountOfflineNotification::set_session_id(const char* value, size_t size) { + set_has_session_id(); + if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + session_id_ = new ::std::string; + } + session_id_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification.session_id) +} +inline ::std::string* GameAccountOfflineNotification::mutable_session_id() { + set_has_session_id(); + if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + session_id_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification.session_id) + return session_id_; +} +inline ::std::string* GameAccountOfflineNotification::release_session_id() { + clear_has_session_id(); + if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = session_id_; + session_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void GameAccountOfflineNotification::set_allocated_session_id(::std::string* session_id) { + if (session_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete session_id_; + } + if (session_id) { + set_has_session_id(); + session_id_ = session_id; + } else { + clear_has_session_id(); + session_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification.session_id) +} + +// ------------------------------------------------------------------- + +// GetAchievementsFileRequest + +// optional .bgs.protocol.ProcessId host = 1; +inline bool GetAchievementsFileRequest::has_host() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GetAchievementsFileRequest::set_has_host() { + _has_bits_[0] |= 0x00000001u; +} +inline void GetAchievementsFileRequest::clear_has_host() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GetAchievementsFileRequest::clear_host() { + if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear(); + clear_has_host(); +} +inline const ::bgs::protocol::ProcessId& GetAchievementsFileRequest::host() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest.host) + return host_ != NULL ? *host_ : *default_instance_->host_; +} +inline ::bgs::protocol::ProcessId* GetAchievementsFileRequest::mutable_host() { + set_has_host(); + if (host_ == NULL) host_ = new ::bgs::protocol::ProcessId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest.host) + return host_; +} +inline ::bgs::protocol::ProcessId* GetAchievementsFileRequest::release_host() { + clear_has_host(); + ::bgs::protocol::ProcessId* temp = host_; + host_ = NULL; + return temp; +} +inline void GetAchievementsFileRequest::set_allocated_host(::bgs::protocol::ProcessId* host) { + delete host_; + host_ = host; + if (host) { + set_has_host(); + } else { + clear_has_host(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest.host) +} + +// ------------------------------------------------------------------- + +// GetAchievementsFileResponse + +// optional .bgs.protocol.ContentHandle content_handle = 1; +inline bool GetAchievementsFileResponse::has_content_handle() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GetAchievementsFileResponse::set_has_content_handle() { + _has_bits_[0] |= 0x00000001u; +} +inline void GetAchievementsFileResponse::clear_has_content_handle() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GetAchievementsFileResponse::clear_content_handle() { + if (content_handle_ != NULL) content_handle_->::bgs::protocol::ContentHandle::Clear(); + clear_has_content_handle(); +} +inline const ::bgs::protocol::ContentHandle& GetAchievementsFileResponse::content_handle() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse.content_handle) + return content_handle_ != NULL ? *content_handle_ : *default_instance_->content_handle_; +} +inline ::bgs::protocol::ContentHandle* GetAchievementsFileResponse::mutable_content_handle() { + set_has_content_handle(); + if (content_handle_ == NULL) content_handle_ = new ::bgs::protocol::ContentHandle; + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse.content_handle) + return content_handle_; +} +inline ::bgs::protocol::ContentHandle* GetAchievementsFileResponse::release_content_handle() { + clear_has_content_handle(); + ::bgs::protocol::ContentHandle* temp = content_handle_; + content_handle_ = NULL; + return temp; +} +inline void GetAchievementsFileResponse::set_allocated_content_handle(::bgs::protocol::ContentHandle* content_handle) { + delete content_handle_; + content_handle_ = content_handle; + if (content_handle) { + set_has_content_handle(); + } else { + clear_has_content_handle(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse.content_handle) +} + +// ------------------------------------------------------------------- + +// GetAllValuesForAttributeRequest + +// optional string attribute_key = 1; +inline bool GetAllValuesForAttributeRequest::has_attribute_key() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GetAllValuesForAttributeRequest::set_has_attribute_key() { + _has_bits_[0] |= 0x00000001u; +} +inline void GetAllValuesForAttributeRequest::clear_has_attribute_key() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GetAllValuesForAttributeRequest::clear_attribute_key() { + if (attribute_key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + attribute_key_->clear(); + } + clear_has_attribute_key(); +} +inline const ::std::string& GetAllValuesForAttributeRequest::attribute_key() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest.attribute_key) + return *attribute_key_; +} +inline void GetAllValuesForAttributeRequest::set_attribute_key(const ::std::string& value) { + set_has_attribute_key(); + if (attribute_key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + attribute_key_ = new ::std::string; + } + attribute_key_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest.attribute_key) +} +inline void GetAllValuesForAttributeRequest::set_attribute_key(const char* value) { + set_has_attribute_key(); + if (attribute_key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + attribute_key_ = new ::std::string; + } + attribute_key_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest.attribute_key) +} +inline void GetAllValuesForAttributeRequest::set_attribute_key(const char* value, size_t size) { + set_has_attribute_key(); + if (attribute_key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + attribute_key_ = new ::std::string; + } + attribute_key_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest.attribute_key) +} +inline ::std::string* GetAllValuesForAttributeRequest::mutable_attribute_key() { + set_has_attribute_key(); + if (attribute_key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + attribute_key_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest.attribute_key) + return attribute_key_; +} +inline ::std::string* GetAllValuesForAttributeRequest::release_attribute_key() { + clear_has_attribute_key(); + if (attribute_key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = attribute_key_; + attribute_key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void GetAllValuesForAttributeRequest::set_allocated_attribute_key(::std::string* attribute_key) { + if (attribute_key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete attribute_key_; + } + if (attribute_key) { + set_has_attribute_key(); + attribute_key_ = attribute_key; + } else { + clear_has_attribute_key(); + attribute_key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest.attribute_key) +} + +// optional .bgs.protocol.EntityId agent_id = 2; +inline bool GetAllValuesForAttributeRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GetAllValuesForAttributeRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void GetAllValuesForAttributeRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GetAllValuesForAttributeRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& GetAllValuesForAttributeRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* GetAllValuesForAttributeRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* GetAllValuesForAttributeRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void GetAllValuesForAttributeRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest.agent_id) +} + +// optional fixed32 program = 5; +inline bool GetAllValuesForAttributeRequest::has_program() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GetAllValuesForAttributeRequest::set_has_program() { + _has_bits_[0] |= 0x00000004u; +} +inline void GetAllValuesForAttributeRequest::clear_has_program() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GetAllValuesForAttributeRequest::clear_program() { + program_ = 0u; + clear_has_program(); +} +inline ::google::protobuf::uint32 GetAllValuesForAttributeRequest::program() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest.program) + return program_; +} +inline void GetAllValuesForAttributeRequest::set_program(::google::protobuf::uint32 value) { + set_has_program(); + program_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest.program) +} + +// ------------------------------------------------------------------- + +// GetAllValuesForAttributeResponse + +// repeated .bgs.protocol.Variant attribute_value = 1; +inline int GetAllValuesForAttributeResponse::attribute_value_size() const { + return attribute_value_.size(); +} +inline void GetAllValuesForAttributeResponse::clear_attribute_value() { + attribute_value_.Clear(); +} +inline const ::bgs::protocol::Variant& GetAllValuesForAttributeResponse::attribute_value(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse.attribute_value) + return attribute_value_.Get(index); +} +inline ::bgs::protocol::Variant* GetAllValuesForAttributeResponse::mutable_attribute_value(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse.attribute_value) + return attribute_value_.Mutable(index); +} +inline ::bgs::protocol::Variant* GetAllValuesForAttributeResponse::add_attribute_value() { + // @@protoc_insertion_point(field_add:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse.attribute_value) + return attribute_value_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Variant >& +GetAllValuesForAttributeResponse::attribute_value() const { + // @@protoc_insertion_point(field_list:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse.attribute_value) + return attribute_value_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Variant >* +GetAllValuesForAttributeResponse::mutable_attribute_value() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse.attribute_value) + return &attribute_value_; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace game_utilities +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_game_5futilities_5fservice_2eproto__INCLUDED diff --git a/src/server/proto/Client/game_utilities_types.pb.cc b/src/server/proto/Client/game_utilities_types.pb.cc new file mode 100644 index 00000000000..cb72ee88ef3 --- /dev/null +++ b/src/server/proto/Client/game_utilities_types.pb.cc @@ -0,0 +1,742 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: game_utilities_types.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "game_utilities_types.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { +namespace game_utilities { +namespace v1 { + +namespace { + +const ::google::protobuf::Descriptor* PlayerVariables_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + PlayerVariables_reflection_ = NULL; +const ::google::protobuf::Descriptor* ClientInfo_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ClientInfo_reflection_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_game_5futilities_5ftypes_2eproto() { + protobuf_AddDesc_game_5futilities_5ftypes_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "game_utilities_types.proto"); + GOOGLE_CHECK(file != NULL); + PlayerVariables_descriptor_ = file->message_type(0); + static const int PlayerVariables_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlayerVariables, identity_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlayerVariables, rating_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlayerVariables, attribute_), + }; + PlayerVariables_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + PlayerVariables_descriptor_, + PlayerVariables::default_instance_, + PlayerVariables_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlayerVariables, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlayerVariables, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(PlayerVariables)); + ClientInfo_descriptor_ = file->message_type(1); + static const int ClientInfo_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientInfo, client_address_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientInfo, privileged_network_), + }; + ClientInfo_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ClientInfo_descriptor_, + ClientInfo::default_instance_, + ClientInfo_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientInfo, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientInfo, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ClientInfo)); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_game_5futilities_5ftypes_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + PlayerVariables_descriptor_, &PlayerVariables::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ClientInfo_descriptor_, &ClientInfo::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_game_5futilities_5ftypes_2eproto() { + delete PlayerVariables::default_instance_; + delete PlayerVariables_reflection_; + delete ClientInfo::default_instance_; + delete ClientInfo_reflection_; +} + +void protobuf_AddDesc_game_5futilities_5ftypes_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\032game_utilities_types.proto\022\036bgs.protoc" + "ol.game_utilities.v1\032\025attribute_types.pr" + "oto\032\022entity_types.proto\"w\n\017PlayerVariabl" + "es\022(\n\010identity\030\001 \002(\0132\026.bgs.protocol.Iden" + "tity\022\016\n\006rating\030\002 \001(\001\022*\n\tattribute\030\003 \003(\0132" + "\027.bgs.protocol.Attribute\"@\n\nClientInfo\022\026" + "\n\016client_address\030\001 \001(\t\022\032\n\022privileged_net" + "work\030\002 \001(\010B<\n\037bnet.protocol.game_utiliti" + "es.v1B\027GameUtilitiesTypesProtoH\001", 352); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "game_utilities_types.proto", &protobuf_RegisterTypes); + PlayerVariables::default_instance_ = new PlayerVariables(); + ClientInfo::default_instance_ = new ClientInfo(); + PlayerVariables::default_instance_->InitAsDefaultInstance(); + ClientInfo::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_game_5futilities_5ftypes_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_game_5futilities_5ftypes_2eproto { + StaticDescriptorInitializer_game_5futilities_5ftypes_2eproto() { + protobuf_AddDesc_game_5futilities_5ftypes_2eproto(); + } +} static_descriptor_initializer_game_5futilities_5ftypes_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int PlayerVariables::kIdentityFieldNumber; +const int PlayerVariables::kRatingFieldNumber; +const int PlayerVariables::kAttributeFieldNumber; +#endif // !_MSC_VER + +PlayerVariables::PlayerVariables() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.PlayerVariables) +} + +void PlayerVariables::InitAsDefaultInstance() { + identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance()); +} + +PlayerVariables::PlayerVariables(const PlayerVariables& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.PlayerVariables) +} + +void PlayerVariables::SharedCtor() { + _cached_size_ = 0; + identity_ = NULL; + rating_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +PlayerVariables::~PlayerVariables() { + // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.PlayerVariables) + SharedDtor(); +} + +void PlayerVariables::SharedDtor() { + if (this != default_instance_) { + delete identity_; + } +} + +void PlayerVariables::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* PlayerVariables::descriptor() { + protobuf_AssignDescriptorsOnce(); + return PlayerVariables_descriptor_; +} + +const PlayerVariables& PlayerVariables::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5ftypes_2eproto(); + return *default_instance_; +} + +PlayerVariables* PlayerVariables::default_instance_ = NULL; + +PlayerVariables* PlayerVariables::New() const { + return new PlayerVariables; +} + +void PlayerVariables::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_identity()) { + if (identity_ != NULL) identity_->::bgs::protocol::Identity::Clear(); + } + rating_ = 0; + } + attribute_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool PlayerVariables::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.PlayerVariables) + 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)) { + // required .bgs.protocol.Identity identity = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_identity())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(17)) goto parse_rating; + break; + } + + // optional double rating = 2; + case 2: { + if (tag == 17) { + parse_rating: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + input, &rating_))); + set_has_rating(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_attribute; + break; + } + + // repeated .bgs.protocol.Attribute attribute = 3; + case 3: { + if (tag == 26) { + parse_attribute: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_attribute())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_attribute; + 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:bgs.protocol.game_utilities.v1.PlayerVariables) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.PlayerVariables) + return false; +#undef DO_ +} + +void PlayerVariables::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.PlayerVariables) + // required .bgs.protocol.Identity identity = 1; + if (has_identity()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->identity(), output); + } + + // optional double rating = 2; + if (has_rating()) { + ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->rating(), output); + } + + // repeated .bgs.protocol.Attribute attribute = 3; + for (int i = 0; i < this->attribute_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->attribute(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.PlayerVariables) +} + +::google::protobuf::uint8* PlayerVariables::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.PlayerVariables) + // required .bgs.protocol.Identity identity = 1; + if (has_identity()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->identity(), target); + } + + // optional double rating = 2; + if (has_rating()) { + target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(2, this->rating(), target); + } + + // repeated .bgs.protocol.Attribute attribute = 3; + for (int i = 0; i < this->attribute_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->attribute(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.PlayerVariables) + return target; +} + +int PlayerVariables::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.Identity identity = 1; + if (has_identity()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->identity()); + } + + // optional double rating = 2; + if (has_rating()) { + total_size += 1 + 8; + } + + } + // repeated .bgs.protocol.Attribute attribute = 3; + total_size += 1 * this->attribute_size(); + for (int i = 0; i < this->attribute_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->attribute(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 PlayerVariables::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const PlayerVariables* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void PlayerVariables::MergeFrom(const PlayerVariables& from) { + GOOGLE_CHECK_NE(&from, this); + attribute_.MergeFrom(from.attribute_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_identity()) { + mutable_identity()->::bgs::protocol::Identity::MergeFrom(from.identity()); + } + if (from.has_rating()) { + set_rating(from.rating()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void PlayerVariables::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void PlayerVariables::CopyFrom(const PlayerVariables& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PlayerVariables::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_identity()) { + if (!this->identity().IsInitialized()) return false; + } + if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false; + return true; +} + +void PlayerVariables::Swap(PlayerVariables* other) { + if (other != this) { + std::swap(identity_, other->identity_); + std::swap(rating_, other->rating_); + attribute_.Swap(&other->attribute_); + 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 PlayerVariables::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = PlayerVariables_descriptor_; + metadata.reflection = PlayerVariables_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ClientInfo::kClientAddressFieldNumber; +const int ClientInfo::kPrivilegedNetworkFieldNumber; +#endif // !_MSC_VER + +ClientInfo::ClientInfo() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.ClientInfo) +} + +void ClientInfo::InitAsDefaultInstance() { +} + +ClientInfo::ClientInfo(const ClientInfo& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.ClientInfo) +} + +void ClientInfo::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + client_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + privileged_network_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ClientInfo::~ClientInfo() { + // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.ClientInfo) + SharedDtor(); +} + +void ClientInfo::SharedDtor() { + if (client_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete client_address_; + } + if (this != default_instance_) { + } +} + +void ClientInfo::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ClientInfo::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ClientInfo_descriptor_; +} + +const ClientInfo& ClientInfo::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5ftypes_2eproto(); + return *default_instance_; +} + +ClientInfo* ClientInfo::default_instance_ = NULL; + +ClientInfo* ClientInfo::New() const { + return new ClientInfo; +} + +void ClientInfo::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_client_address()) { + if (client_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_address_->clear(); + } + } + privileged_network_ = false; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ClientInfo::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.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 string client_address = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_client_address())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->client_address().data(), this->client_address().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "client_address"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_privileged_network; + break; + } + + // optional bool privileged_network = 2; + case 2: { + if (tag == 16) { + parse_privileged_network: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &privileged_network_))); + set_has_privileged_network(); + } 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:bgs.protocol.game_utilities.v1.ClientInfo) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.ClientInfo) + return false; +#undef DO_ +} + +void ClientInfo::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.ClientInfo) + // optional string client_address = 1; + if (has_client_address()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->client_address().data(), this->client_address().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "client_address"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->client_address(), output); + } + + // optional bool privileged_network = 2; + if (has_privileged_network()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->privileged_network(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.ClientInfo) +} + +::google::protobuf::uint8* ClientInfo::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.ClientInfo) + // optional string client_address = 1; + if (has_client_address()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->client_address().data(), this->client_address().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "client_address"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->client_address(), target); + } + + // optional bool privileged_network = 2; + if (has_privileged_network()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->privileged_network(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.ClientInfo) + return target; +} + +int ClientInfo::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional string client_address = 1; + if (has_client_address()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->client_address()); + } + + // optional bool privileged_network = 2; + if (has_privileged_network()) { + 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 ClientInfo::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ClientInfo* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ClientInfo::MergeFrom(const ClientInfo& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_client_address()) { + set_client_address(from.client_address()); + } + if (from.has_privileged_network()) { + set_privileged_network(from.privileged_network()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ClientInfo::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ClientInfo::CopyFrom(const ClientInfo& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ClientInfo::IsInitialized() const { + + return true; +} + +void ClientInfo::Swap(ClientInfo* other) { + if (other != this) { + std::swap(client_address_, other->client_address_); + std::swap(privileged_network_, other->privileged_network_); + 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 ClientInfo::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ClientInfo_descriptor_; + metadata.reflection = ClientInfo_reflection_; + return metadata; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace game_utilities +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/game_utilities_types.pb.h b/src/server/proto/Client/game_utilities_types.pb.h new file mode 100644 index 00000000000..dc9a1eb4060 --- /dev/null +++ b/src/server/proto/Client/game_utilities_types.pb.h @@ -0,0 +1,471 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: game_utilities_types.proto + +#ifndef PROTOBUF_game_5futilities_5ftypes_2eproto__INCLUDED +#define PROTOBUF_game_5futilities_5ftypes_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include "attribute_types.pb.h" +#include "entity_types.pb.h" +#include "Define.h" // for TRINITY_SHARED_API +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { +namespace game_utilities { +namespace v1 { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_game_5futilities_5ftypes_2eproto(); +void protobuf_AssignDesc_game_5futilities_5ftypes_2eproto(); +void protobuf_ShutdownFile_game_5futilities_5ftypes_2eproto(); + +class PlayerVariables; +class ClientInfo; + +// =================================================================== + +class TC_SHARED_API PlayerVariables : public ::google::protobuf::Message { + public: + PlayerVariables(); + virtual ~PlayerVariables(); + + PlayerVariables(const PlayerVariables& from); + + inline PlayerVariables& operator=(const PlayerVariables& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const PlayerVariables& default_instance(); + + void Swap(PlayerVariables* other); + + // implements Message ---------------------------------------------- + + PlayerVariables* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const PlayerVariables& from); + void MergeFrom(const PlayerVariables& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.Identity identity = 1; + inline bool has_identity() const; + inline void clear_identity(); + static const int kIdentityFieldNumber = 1; + inline const ::bgs::protocol::Identity& identity() const; + inline ::bgs::protocol::Identity* mutable_identity(); + inline ::bgs::protocol::Identity* release_identity(); + inline void set_allocated_identity(::bgs::protocol::Identity* identity); + + // optional double rating = 2; + inline bool has_rating() const; + inline void clear_rating(); + static const int kRatingFieldNumber = 2; + inline double rating() const; + inline void set_rating(double value); + + // repeated .bgs.protocol.Attribute attribute = 3; + inline int attribute_size() const; + inline void clear_attribute(); + static const int kAttributeFieldNumber = 3; + inline const ::bgs::protocol::Attribute& attribute(int index) const; + inline ::bgs::protocol::Attribute* mutable_attribute(int index); + inline ::bgs::protocol::Attribute* add_attribute(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& + attribute() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* + mutable_attribute(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.PlayerVariables) + private: + inline void set_has_identity(); + inline void clear_has_identity(); + inline void set_has_rating(); + inline void clear_has_rating(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::Identity* identity_; + double rating_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_; + friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5ftypes_2eproto(); + friend void protobuf_AssignDesc_game_5futilities_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_game_5futilities_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static PlayerVariables* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ClientInfo : public ::google::protobuf::Message { + public: + ClientInfo(); + virtual ~ClientInfo(); + + ClientInfo(const ClientInfo& from); + + inline ClientInfo& operator=(const ClientInfo& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ClientInfo& default_instance(); + + void Swap(ClientInfo* other); + + // implements Message ---------------------------------------------- + + ClientInfo* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ClientInfo& from); + void MergeFrom(const ClientInfo& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string client_address = 1; + inline bool has_client_address() const; + inline void clear_client_address(); + static const int kClientAddressFieldNumber = 1; + inline const ::std::string& client_address() const; + inline void set_client_address(const ::std::string& value); + inline void set_client_address(const char* value); + inline void set_client_address(const char* value, size_t size); + inline ::std::string* mutable_client_address(); + inline ::std::string* release_client_address(); + inline void set_allocated_client_address(::std::string* client_address); + + // optional bool privileged_network = 2; + inline bool has_privileged_network() const; + inline void clear_privileged_network(); + static const int kPrivilegedNetworkFieldNumber = 2; + inline bool privileged_network() const; + inline void set_privileged_network(bool value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.ClientInfo) + private: + inline void set_has_client_address(); + inline void clear_has_client_address(); + inline void set_has_privileged_network(); + inline void clear_has_privileged_network(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* client_address_; + bool privileged_network_; + friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5ftypes_2eproto(); + friend void protobuf_AssignDesc_game_5futilities_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_game_5futilities_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static ClientInfo* default_instance_; +}; +// =================================================================== + + +// =================================================================== + + +// =================================================================== + +// PlayerVariables + +// required .bgs.protocol.Identity identity = 1; +inline bool PlayerVariables::has_identity() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void PlayerVariables::set_has_identity() { + _has_bits_[0] |= 0x00000001u; +} +inline void PlayerVariables::clear_has_identity() { + _has_bits_[0] &= ~0x00000001u; +} +inline void PlayerVariables::clear_identity() { + if (identity_ != NULL) identity_->::bgs::protocol::Identity::Clear(); + clear_has_identity(); +} +inline const ::bgs::protocol::Identity& PlayerVariables::identity() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.PlayerVariables.identity) + return identity_ != NULL ? *identity_ : *default_instance_->identity_; +} +inline ::bgs::protocol::Identity* PlayerVariables::mutable_identity() { + set_has_identity(); + if (identity_ == NULL) identity_ = new ::bgs::protocol::Identity; + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.PlayerVariables.identity) + return identity_; +} +inline ::bgs::protocol::Identity* PlayerVariables::release_identity() { + clear_has_identity(); + ::bgs::protocol::Identity* temp = identity_; + identity_ = NULL; + return temp; +} +inline void PlayerVariables::set_allocated_identity(::bgs::protocol::Identity* identity) { + delete identity_; + identity_ = identity; + if (identity) { + set_has_identity(); + } else { + clear_has_identity(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.PlayerVariables.identity) +} + +// optional double rating = 2; +inline bool PlayerVariables::has_rating() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void PlayerVariables::set_has_rating() { + _has_bits_[0] |= 0x00000002u; +} +inline void PlayerVariables::clear_has_rating() { + _has_bits_[0] &= ~0x00000002u; +} +inline void PlayerVariables::clear_rating() { + rating_ = 0; + clear_has_rating(); +} +inline double PlayerVariables::rating() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.PlayerVariables.rating) + return rating_; +} +inline void PlayerVariables::set_rating(double value) { + set_has_rating(); + rating_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.game_utilities.v1.PlayerVariables.rating) +} + +// repeated .bgs.protocol.Attribute attribute = 3; +inline int PlayerVariables::attribute_size() const { + return attribute_.size(); +} +inline void PlayerVariables::clear_attribute() { + attribute_.Clear(); +} +inline const ::bgs::protocol::Attribute& PlayerVariables::attribute(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.PlayerVariables.attribute) + return attribute_.Get(index); +} +inline ::bgs::protocol::Attribute* PlayerVariables::mutable_attribute(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.PlayerVariables.attribute) + return attribute_.Mutable(index); +} +inline ::bgs::protocol::Attribute* PlayerVariables::add_attribute() { + // @@protoc_insertion_point(field_add:bgs.protocol.game_utilities.v1.PlayerVariables.attribute) + return attribute_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& +PlayerVariables::attribute() const { + // @@protoc_insertion_point(field_list:bgs.protocol.game_utilities.v1.PlayerVariables.attribute) + return attribute_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* +PlayerVariables::mutable_attribute() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.game_utilities.v1.PlayerVariables.attribute) + return &attribute_; +} + +// ------------------------------------------------------------------- + +// ClientInfo + +// optional string client_address = 1; +inline bool ClientInfo::has_client_address() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ClientInfo::set_has_client_address() { + _has_bits_[0] |= 0x00000001u; +} +inline void ClientInfo::clear_has_client_address() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ClientInfo::clear_client_address() { + if (client_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_address_->clear(); + } + clear_has_client_address(); +} +inline const ::std::string& ClientInfo::client_address() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ClientInfo.client_address) + return *client_address_; +} +inline void ClientInfo::set_client_address(const ::std::string& value) { + set_has_client_address(); + if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_address_ = new ::std::string; + } + client_address_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.game_utilities.v1.ClientInfo.client_address) +} +inline void ClientInfo::set_client_address(const char* value) { + set_has_client_address(); + if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_address_ = new ::std::string; + } + client_address_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.game_utilities.v1.ClientInfo.client_address) +} +inline void ClientInfo::set_client_address(const char* value, size_t size) { + set_has_client_address(); + if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_address_ = new ::std::string; + } + client_address_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.game_utilities.v1.ClientInfo.client_address) +} +inline ::std::string* ClientInfo::mutable_client_address() { + set_has_client_address(); + if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_address_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.ClientInfo.client_address) + return client_address_; +} +inline ::std::string* ClientInfo::release_client_address() { + clear_has_client_address(); + if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = client_address_; + client_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ClientInfo::set_allocated_client_address(::std::string* client_address) { + if (client_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete client_address_; + } + if (client_address) { + set_has_client_address(); + client_address_ = client_address; + } else { + clear_has_client_address(); + client_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.ClientInfo.client_address) +} + +// optional bool privileged_network = 2; +inline bool ClientInfo::has_privileged_network() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ClientInfo::set_has_privileged_network() { + _has_bits_[0] |= 0x00000002u; +} +inline void ClientInfo::clear_has_privileged_network() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ClientInfo::clear_privileged_network() { + privileged_network_ = false; + clear_has_privileged_network(); +} +inline bool ClientInfo::privileged_network() const { + // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ClientInfo.privileged_network) + return privileged_network_; +} +inline void ClientInfo::set_privileged_network(bool value) { + set_has_privileged_network(); + privileged_network_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.game_utilities.v1.ClientInfo.privileged_network) +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace game_utilities +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_game_5futilities_5ftypes_2eproto__INCLUDED diff --git a/src/server/proto/Client/global_extensions/field_options.pb.cc b/src/server/proto/Client/global_extensions/field_options.pb.cc new file mode 100644 index 00000000000..f5a1e999417 --- /dev/null +++ b/src/server/proto/Client/global_extensions/field_options.pb.cc @@ -0,0 +1,114 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: global_extensions/field_options.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "global_extensions/field_options.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { + +namespace { + +const ::google::protobuf::EnumDescriptor* LogOption_descriptor_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto() { + protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "global_extensions/field_options.proto"); + GOOGLE_CHECK(file != NULL); + LogOption_descriptor_ = file->enum_type(0); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); +} + +} // namespace + +void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto() { +} + +void protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::google::protobuf::protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n%global_extensions/field_options.proto\022" + "\014bgs.protocol\032 google/protobuf/descripto" + "r.proto* \n\tLogOption\022\n\n\006HIDDEN\020\001\022\007\n\003HEX\020" + "\002:E\n\003log\022\035.google.protobuf.FieldOptions\030" + "\320\206\003 \001(\0162\027.bgs.protocol.LogOptionB$\n\rbnet" + ".protocolB\021FieldOptionsProtoH\001", 230); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "global_extensions/field_options.proto", &protobuf_RegisterTypes); + ::google::protobuf::internal::ExtensionSet::RegisterEnumExtension( + &::google::protobuf::FieldOptions::default_instance(), + 50000, 14, false, false, + &::bgs::protocol::LogOption_IsValid); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_global_5fextensions_2ffield_5foptions_2eproto { + StaticDescriptorInitializer_global_5fextensions_2ffield_5foptions_2eproto() { + protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto(); + } +} static_descriptor_initializer_global_5fextensions_2ffield_5foptions_2eproto_; +const ::google::protobuf::EnumDescriptor* LogOption_descriptor() { + protobuf_AssignDescriptorsOnce(); + return LogOption_descriptor_; +} +bool LogOption_IsValid(int value) { + switch(value) { + case 1: + case 2: + return true; + default: + return false; + } +} + +::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::FieldOptions, + ::google::protobuf::internal::EnumTypeTraits< ::bgs::protocol::LogOption, ::bgs::protocol::LogOption_IsValid>, 14, false > + log(kLogFieldNumber, static_cast< ::bgs::protocol::LogOption >(1)); + +// @@protoc_insertion_point(namespace_scope) + +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/global_extensions/field_options.pb.h b/src/server/proto/Client/global_extensions/field_options.pb.h new file mode 100644 index 00000000000..3dce90f83f0 --- /dev/null +++ b/src/server/proto/Client/global_extensions/field_options.pb.h @@ -0,0 +1,95 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: global_extensions/field_options.proto + +#ifndef PROTOBUF_global_5fextensions_2ffield_5foptions_2eproto__INCLUDED +#define PROTOBUF_global_5fextensions_2ffield_5foptions_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include "google/protobuf/descriptor.pb.h" +#include "Define.h" // for TRINITY_SHARED_API +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto(); +void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto(); +void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto(); + + +enum LogOption { + HIDDEN = 1, + HEX = 2 +}; +TC_SHARED_API bool LogOption_IsValid(int value); +const LogOption LogOption_MIN = HIDDEN; +const LogOption LogOption_MAX = HEX; +const int LogOption_ARRAYSIZE = LogOption_MAX + 1; + +TC_SHARED_API const ::google::protobuf::EnumDescriptor* LogOption_descriptor(); +inline const ::std::string& LogOption_Name(LogOption value) { + return ::google::protobuf::internal::NameOfEnum( + LogOption_descriptor(), value); +} +inline bool LogOption_Parse( + const ::std::string& name, LogOption* value) { + return ::google::protobuf::internal::ParseNamedEnum( + LogOption_descriptor(), name, value); +} +// =================================================================== + + +// =================================================================== + + +// =================================================================== + +static const int kLogFieldNumber = 50000; +TC_SHARED_API extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::FieldOptions, + ::google::protobuf::internal::EnumTypeTraits< ::bgs::protocol::LogOption, ::bgs::protocol::LogOption_IsValid>, 14, false > + log; + +// =================================================================== + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + +template <> struct is_proto_enum< ::bgs::protocol::LogOption> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::LogOption>() { + return ::bgs::protocol::LogOption_descriptor(); +} + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_global_5fextensions_2ffield_5foptions_2eproto__INCLUDED diff --git a/src/server/proto/Client/global_extensions/method_options.pb.cc b/src/server/proto/Client/global_extensions/method_options.pb.cc new file mode 100644 index 00000000000..ad95780a845 --- /dev/null +++ b/src/server/proto/Client/global_extensions/method_options.pb.cc @@ -0,0 +1,96 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: global_extensions/method_options.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "global_extensions/method_options.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { + +namespace { + + +} // namespace + + +void protobuf_AssignDesc_global_5fextensions_2fmethod_5foptions_2eproto() { + protobuf_AddDesc_global_5fextensions_2fmethod_5foptions_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "global_extensions/method_options.proto"); + GOOGLE_CHECK(file != NULL); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_global_5fextensions_2fmethod_5foptions_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); +} + +} // namespace + +void protobuf_ShutdownFile_global_5fextensions_2fmethod_5foptions_2eproto() { +} + +void protobuf_AddDesc_global_5fextensions_2fmethod_5foptions_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::google::protobuf::protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n&global_extensions/method_options.proto" + "\022\014bgs.protocol\032 google/protobuf/descript" + "or.proto:3\n\tmethod_id\022\036.google.protobuf." + "MethodOptions\030\320\206\003 \001(\rB%\n\rbnet.protocolB\022" + "MethodOptionsProtoH\001", 180); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "global_extensions/method_options.proto", &protobuf_RegisterTypes); + ::google::protobuf::internal::ExtensionSet::RegisterExtension( + &::google::protobuf::MethodOptions::default_instance(), + 50000, 13, false, false); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_global_5fextensions_2fmethod_5foptions_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_global_5fextensions_2fmethod_5foptions_2eproto { + StaticDescriptorInitializer_global_5fextensions_2fmethod_5foptions_2eproto() { + protobuf_AddDesc_global_5fextensions_2fmethod_5foptions_2eproto(); + } +} static_descriptor_initializer_global_5fextensions_2fmethod_5foptions_2eproto_; +::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::MethodOptions, + ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 13, false > + method_id(kMethodIdFieldNumber, 0u); + +// @@protoc_insertion_point(namespace_scope) + +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/global_extensions/method_options.pb.h b/src/server/proto/Client/global_extensions/method_options.pb.h new file mode 100644 index 00000000000..68e13db4a4c --- /dev/null +++ b/src/server/proto/Client/global_extensions/method_options.pb.h @@ -0,0 +1,70 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: global_extensions/method_options.proto + +#ifndef PROTOBUF_global_5fextensions_2fmethod_5foptions_2eproto__INCLUDED +#define PROTOBUF_global_5fextensions_2fmethod_5foptions_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include "google/protobuf/descriptor.pb.h" +#include "Define.h" // for TRINITY_SHARED_API +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_global_5fextensions_2fmethod_5foptions_2eproto(); +void protobuf_AssignDesc_global_5fextensions_2fmethod_5foptions_2eproto(); +void protobuf_ShutdownFile_global_5fextensions_2fmethod_5foptions_2eproto(); + + +// =================================================================== + + +// =================================================================== + + +// =================================================================== + +static const int kMethodIdFieldNumber = 50000; +TC_SHARED_API extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::MethodOptions, + ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 13, false > + method_id; + +// =================================================================== + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_global_5fextensions_2fmethod_5foptions_2eproto__INCLUDED diff --git a/src/server/proto/Client/global_extensions/service_options.pb.cc b/src/server/proto/Client/global_extensions/service_options.pb.cc new file mode 100644 index 00000000000..6bd0768c9a9 --- /dev/null +++ b/src/server/proto/Client/global_extensions/service_options.pb.cc @@ -0,0 +1,105 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: global_extensions/service_options.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "global_extensions/service_options.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { + +namespace { + + +} // namespace + + +void protobuf_AssignDesc_global_5fextensions_2fservice_5foptions_2eproto() { + protobuf_AddDesc_global_5fextensions_2fservice_5foptions_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "global_extensions/service_options.proto"); + GOOGLE_CHECK(file != NULL); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_global_5fextensions_2fservice_5foptions_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); +} + +} // namespace + +void protobuf_ShutdownFile_global_5fextensions_2fservice_5foptions_2eproto() { +} + +void protobuf_AddDesc_global_5fextensions_2fservice_5foptions_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::google::protobuf::protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\'global_extensions/service_options.prot" + "o\022\014bgs.protocol\032 google/protobuf/descrip" + "tor.proto:R\n(original_fully_qualified_de" + "scriptor_name\022\037.google.protobuf.ServiceO" + "ptions\030\351\007 \001(\t:5\n\nservice_id\022\037.google.pro" + "tobuf.ServiceOptions\030\320\206\003 \001(\rB&\n\rbnet.pro" + "tocolB\023ServiceOptionsProtoH\001", 268); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "global_extensions/service_options.proto", &protobuf_RegisterTypes); + ::google::protobuf::internal::ExtensionSet::RegisterExtension( + &::google::protobuf::ServiceOptions::default_instance(), + 1001, 9, false, false); + ::google::protobuf::internal::ExtensionSet::RegisterExtension( + &::google::protobuf::ServiceOptions::default_instance(), + 50000, 13, false, false); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_global_5fextensions_2fservice_5foptions_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_global_5fextensions_2fservice_5foptions_2eproto { + StaticDescriptorInitializer_global_5fextensions_2fservice_5foptions_2eproto() { + protobuf_AddDesc_global_5fextensions_2fservice_5foptions_2eproto(); + } +} static_descriptor_initializer_global_5fextensions_2fservice_5foptions_2eproto_; +const ::std::string original_fully_qualified_descriptor_name_default(""); +::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::ServiceOptions, + ::google::protobuf::internal::StringTypeTraits, 9, false > + original_fully_qualified_descriptor_name(kOriginalFullyQualifiedDescriptorNameFieldNumber, original_fully_qualified_descriptor_name_default); +::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::ServiceOptions, + ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 13, false > + service_id(kServiceIdFieldNumber, 0u); + +// @@protoc_insertion_point(namespace_scope) + +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/global_extensions/service_options.pb.h b/src/server/proto/Client/global_extensions/service_options.pb.h new file mode 100644 index 00000000000..5188e246ea5 --- /dev/null +++ b/src/server/proto/Client/global_extensions/service_options.pb.h @@ -0,0 +1,74 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: global_extensions/service_options.proto + +#ifndef PROTOBUF_global_5fextensions_2fservice_5foptions_2eproto__INCLUDED +#define PROTOBUF_global_5fextensions_2fservice_5foptions_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include "google/protobuf/descriptor.pb.h" +#include "Define.h" // for TRINITY_SHARED_API +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_global_5fextensions_2fservice_5foptions_2eproto(); +void protobuf_AssignDesc_global_5fextensions_2fservice_5foptions_2eproto(); +void protobuf_ShutdownFile_global_5fextensions_2fservice_5foptions_2eproto(); + + +// =================================================================== + + +// =================================================================== + + +// =================================================================== + +static const int kOriginalFullyQualifiedDescriptorNameFieldNumber = 1001; +TC_SHARED_API extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::ServiceOptions, + ::google::protobuf::internal::StringTypeTraits, 9, false > + original_fully_qualified_descriptor_name; +static const int kServiceIdFieldNumber = 50000; +TC_SHARED_API extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::ServiceOptions, + ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 13, false > + service_id; + +// =================================================================== + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_global_5fextensions_2fservice_5foptions_2eproto__INCLUDED diff --git a/src/server/proto/Client/invitation_types.pb.cc b/src/server/proto/Client/invitation_types.pb.cc new file mode 100644 index 00000000000..f166d4bd280 --- /dev/null +++ b/src/server/proto/Client/invitation_types.pb.cc @@ -0,0 +1,3684 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: invitation_types.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "invitation_types.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { + +namespace { + +const ::google::protobuf::Descriptor* Invitation_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Invitation_reflection_ = NULL; +const ::google::protobuf::Descriptor* InvitationSuggestion_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + InvitationSuggestion_reflection_ = NULL; +const ::google::protobuf::Descriptor* InvitationTarget_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + InvitationTarget_reflection_ = NULL; +const ::google::protobuf::Descriptor* InvitationParams_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + InvitationParams_reflection_ = NULL; +const ::google::protobuf::Descriptor* SendInvitationRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SendInvitationRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* SendInvitationResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SendInvitationResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* UpdateInvitationRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + UpdateInvitationRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* GenericInvitationRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GenericInvitationRequest_reflection_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_invitation_5ftypes_2eproto() { + protobuf_AddDesc_invitation_5ftypes_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "invitation_types.proto"); + GOOGLE_CHECK(file != NULL); + Invitation_descriptor_ = file->message_type(0); + static const int Invitation_offsets_[8] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Invitation, id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Invitation, inviter_identity_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Invitation, invitee_identity_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Invitation, inviter_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Invitation, invitee_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Invitation, invitation_message_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Invitation, creation_time_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Invitation, expiration_time_), + }; + Invitation_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Invitation_descriptor_, + Invitation::default_instance_, + Invitation_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Invitation, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Invitation, _unknown_fields_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Invitation, _extensions_), + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Invitation)); + InvitationSuggestion_descriptor_ = file->message_type(1); + static const int InvitationSuggestion_offsets_[6] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationSuggestion, channel_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationSuggestion, suggester_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationSuggestion, suggestee_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationSuggestion, suggester_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationSuggestion, suggestee_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationSuggestion, suggester_account_id_), + }; + InvitationSuggestion_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + InvitationSuggestion_descriptor_, + InvitationSuggestion::default_instance_, + InvitationSuggestion_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationSuggestion, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationSuggestion, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(InvitationSuggestion)); + InvitationTarget_descriptor_ = file->message_type(2); + static const int InvitationTarget_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationTarget, identity_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationTarget, email_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationTarget, battle_tag_), + }; + InvitationTarget_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + InvitationTarget_descriptor_, + InvitationTarget::default_instance_, + InvitationTarget_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationTarget, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationTarget, _unknown_fields_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationTarget, _extensions_), + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(InvitationTarget)); + InvitationParams_descriptor_ = file->message_type(3); + static const int InvitationParams_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationParams, invitation_message_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationParams, expiration_time_), + }; + InvitationParams_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + InvitationParams_descriptor_, + InvitationParams::default_instance_, + InvitationParams_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationParams, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationParams, _unknown_fields_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationParams, _extensions_), + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(InvitationParams)); + SendInvitationRequest_descriptor_ = file->message_type(4); + static const int SendInvitationRequest_offsets_[5] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, agent_identity_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, target_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, params_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, agent_info_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, target_), + }; + SendInvitationRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + SendInvitationRequest_descriptor_, + SendInvitationRequest::default_instance_, + SendInvitationRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(SendInvitationRequest)); + SendInvitationResponse_descriptor_ = file->message_type(5); + static const int SendInvitationResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationResponse, invitation_), + }; + SendInvitationResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + SendInvitationResponse_descriptor_, + SendInvitationResponse::default_instance_, + SendInvitationResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(SendInvitationResponse)); + UpdateInvitationRequest_descriptor_ = file->message_type(6); + static const int UpdateInvitationRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateInvitationRequest, agent_identity_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateInvitationRequest, invitation_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateInvitationRequest, params_), + }; + UpdateInvitationRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + UpdateInvitationRequest_descriptor_, + UpdateInvitationRequest::default_instance_, + UpdateInvitationRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateInvitationRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateInvitationRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(UpdateInvitationRequest)); + GenericInvitationRequest_descriptor_ = file->message_type(7); + static const int GenericInvitationRequest_offsets_[8] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, target_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, invitation_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, invitee_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, inviter_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, previous_role_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, desired_role_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, reason_), + }; + GenericInvitationRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GenericInvitationRequest_descriptor_, + GenericInvitationRequest::default_instance_, + GenericInvitationRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GenericInvitationRequest)); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_invitation_5ftypes_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Invitation_descriptor_, &Invitation::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + InvitationSuggestion_descriptor_, &InvitationSuggestion::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + InvitationTarget_descriptor_, &InvitationTarget::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + InvitationParams_descriptor_, &InvitationParams::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SendInvitationRequest_descriptor_, &SendInvitationRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SendInvitationResponse_descriptor_, &SendInvitationResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + UpdateInvitationRequest_descriptor_, &UpdateInvitationRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GenericInvitationRequest_descriptor_, &GenericInvitationRequest::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_invitation_5ftypes_2eproto() { + delete Invitation::default_instance_; + delete Invitation_reflection_; + delete InvitationSuggestion::default_instance_; + delete InvitationSuggestion_reflection_; + delete InvitationTarget::default_instance_; + delete InvitationTarget_reflection_; + delete InvitationParams::default_instance_; + delete InvitationParams_reflection_; + delete SendInvitationRequest::default_instance_; + delete SendInvitationRequest_reflection_; + delete SendInvitationResponse::default_instance_; + delete SendInvitationResponse_reflection_; + delete UpdateInvitationRequest::default_instance_; + delete UpdateInvitationRequest_reflection_; + delete GenericInvitationRequest::default_instance_; + delete GenericInvitationRequest_reflection_; +} + +void protobuf_AddDesc_invitation_5ftypes_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\026invitation_types.proto\022\014bgs.protocol\032\022" + "entity_types.proto\"\373\001\n\nInvitation\022\n\n\002id\030" + "\001 \002(\006\0220\n\020inviter_identity\030\002 \002(\0132\026.bgs.pr" + "otocol.Identity\0220\n\020invitee_identity\030\003 \002(" + "\0132\026.bgs.protocol.Identity\022\024\n\014inviter_nam" + "e\030\004 \001(\t\022\024\n\014invitee_name\030\005 \001(\t\022\032\n\022invitat" + "ion_message\030\006 \001(\t\022\025\n\rcreation_time\030\007 \001(\004" + "\022\027\n\017expiration_time\030\010 \001(\004*\005\010d\020\220N\"\204\002\n\024Inv" + "itationSuggestion\022*\n\nchannel_id\030\001 \001(\0132\026." + "bgs.protocol.EntityId\022,\n\014suggester_id\030\002 " + "\002(\0132\026.bgs.protocol.EntityId\022,\n\014suggestee" + "_id\030\003 \002(\0132\026.bgs.protocol.EntityId\022\026\n\016sug" + "gester_name\030\004 \001(\t\022\026\n\016suggestee_name\030\005 \001(" + "\t\0224\n\024suggester_account_id\030\006 \001(\0132\026.bgs.pr" + "otocol.EntityId\"f\n\020InvitationTarget\022(\n\010i" + "dentity\030\001 \001(\0132\026.bgs.protocol.Identity\022\r\n" + "\005email\030\002 \001(\t\022\022\n\nbattle_tag\030\003 \001(\t*\005\010d\020\220N\"" + "Q\n\020InvitationParams\022\032\n\022invitation_messag" + "e\030\001 \001(\t\022\032\n\017expiration_time\030\002 \001(\004:\0010*\005\010d\020" + "\220N\"\205\002\n\025SendInvitationRequest\022.\n\016agent_id" + "entity\030\001 \001(\0132\026.bgs.protocol.Identity\022-\n\t" + "target_id\030\002 \002(\0132\026.bgs.protocol.EntityIdB" + "\002\030\001\022.\n\006params\030\003 \002(\0132\036.bgs.protocol.Invit" + "ationParams\022-\n\nagent_info\030\004 \001(\0132\031.bgs.pr" + "otocol.AccountInfo\022.\n\006target\030\005 \001(\0132\036.bgs" + ".protocol.InvitationTarget\"F\n\026SendInvita" + "tionResponse\022,\n\ninvitation\030\002 \001(\0132\030.bgs.p" + "rotocol.Invitation\"\220\001\n\027UpdateInvitationR" + "equest\022.\n\016agent_identity\030\001 \001(\0132\026.bgs.pro" + "tocol.Identity\022\025\n\rinvitation_id\030\002 \002(\006\022.\n" + "\006params\030\003 \002(\0132\036.bgs.protocol.InvitationP" + "arams\"\367\001\n\030GenericInvitationRequest\022(\n\010ag" + "ent_id\030\001 \001(\0132\026.bgs.protocol.EntityId\022)\n\t" + "target_id\030\002 \001(\0132\026.bgs.protocol.EntityId\022" + "\025\n\rinvitation_id\030\003 \002(\006\022\024\n\014invitee_name\030\004" + " \001(\t\022\024\n\014inviter_name\030\005 \001(\t\022\031\n\rprevious_r" + "ole\030\006 \003(\rB\002\020\001\022\030\n\014desired_role\030\007 \003(\rB\002\020\001\022" + "\016\n\006reason\030\010 \001(\rB\'\n\rbnet.protocolB\024Invita" + "tionTypesProtoH\001", 1536); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "invitation_types.proto", &protobuf_RegisterTypes); + Invitation::default_instance_ = new Invitation(); + InvitationSuggestion::default_instance_ = new InvitationSuggestion(); + InvitationTarget::default_instance_ = new InvitationTarget(); + InvitationParams::default_instance_ = new InvitationParams(); + SendInvitationRequest::default_instance_ = new SendInvitationRequest(); + SendInvitationResponse::default_instance_ = new SendInvitationResponse(); + UpdateInvitationRequest::default_instance_ = new UpdateInvitationRequest(); + GenericInvitationRequest::default_instance_ = new GenericInvitationRequest(); + Invitation::default_instance_->InitAsDefaultInstance(); + InvitationSuggestion::default_instance_->InitAsDefaultInstance(); + InvitationTarget::default_instance_->InitAsDefaultInstance(); + InvitationParams::default_instance_->InitAsDefaultInstance(); + SendInvitationRequest::default_instance_->InitAsDefaultInstance(); + SendInvitationResponse::default_instance_->InitAsDefaultInstance(); + UpdateInvitationRequest::default_instance_->InitAsDefaultInstance(); + GenericInvitationRequest::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_invitation_5ftypes_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_invitation_5ftypes_2eproto { + StaticDescriptorInitializer_invitation_5ftypes_2eproto() { + protobuf_AddDesc_invitation_5ftypes_2eproto(); + } +} static_descriptor_initializer_invitation_5ftypes_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int Invitation::kIdFieldNumber; +const int Invitation::kInviterIdentityFieldNumber; +const int Invitation::kInviteeIdentityFieldNumber; +const int Invitation::kInviterNameFieldNumber; +const int Invitation::kInviteeNameFieldNumber; +const int Invitation::kInvitationMessageFieldNumber; +const int Invitation::kCreationTimeFieldNumber; +const int Invitation::kExpirationTimeFieldNumber; +#endif // !_MSC_VER + +Invitation::Invitation() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.Invitation) +} + +void Invitation::InitAsDefaultInstance() { + inviter_identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance()); + invitee_identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance()); +} + +Invitation::Invitation(const Invitation& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.Invitation) +} + +void Invitation::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + id_ = GOOGLE_ULONGLONG(0); + inviter_identity_ = NULL; + invitee_identity_ = NULL; + inviter_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + invitee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + invitation_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + creation_time_ = GOOGLE_ULONGLONG(0); + expiration_time_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Invitation::~Invitation() { + // @@protoc_insertion_point(destructor:bgs.protocol.Invitation) + SharedDtor(); +} + +void Invitation::SharedDtor() { + if (inviter_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete inviter_name_; + } + if (invitee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete invitee_name_; + } + if (invitation_message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete invitation_message_; + } + if (this != default_instance_) { + delete inviter_identity_; + delete invitee_identity_; + } +} + +void Invitation::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Invitation::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Invitation_descriptor_; +} + +const Invitation& Invitation::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_invitation_5ftypes_2eproto(); + return *default_instance_; +} + +Invitation* Invitation::default_instance_ = NULL; + +Invitation* Invitation::New() const { + return new Invitation; +} + +void Invitation::Clear() { + _extensions_.Clear(); +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(creation_time_, expiration_time_); + id_ = GOOGLE_ULONGLONG(0); + if (has_inviter_identity()) { + if (inviter_identity_ != NULL) inviter_identity_->::bgs::protocol::Identity::Clear(); + } + if (has_invitee_identity()) { + if (invitee_identity_ != NULL) invitee_identity_->::bgs::protocol::Identity::Clear(); + } + if (has_inviter_name()) { + if (inviter_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + inviter_name_->clear(); + } + } + if (has_invitee_name()) { + if (invitee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitee_name_->clear(); + } + } + if (has_invitation_message()) { + if (invitation_message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitation_message_->clear(); + } + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Invitation::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.Invitation) + 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)) { + // required fixed64 id = 1; + case 1: { + if (tag == 9) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &id_))); + set_has_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_inviter_identity; + break; + } + + // required .bgs.protocol.Identity inviter_identity = 2; + case 2: { + if (tag == 18) { + parse_inviter_identity: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_inviter_identity())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_invitee_identity; + break; + } + + // required .bgs.protocol.Identity invitee_identity = 3; + case 3: { + if (tag == 26) { + parse_invitee_identity: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_invitee_identity())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_inviter_name; + break; + } + + // optional string inviter_name = 4; + case 4: { + if (tag == 34) { + parse_inviter_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_inviter_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->inviter_name().data(), this->inviter_name().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "inviter_name"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_invitee_name; + break; + } + + // optional string invitee_name = 5; + case 5: { + if (tag == 42) { + parse_invitee_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_invitee_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->invitee_name().data(), this->invitee_name().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "invitee_name"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_invitation_message; + break; + } + + // optional string invitation_message = 6; + case 6: { + if (tag == 50) { + parse_invitation_message: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_invitation_message())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->invitation_message().data(), this->invitation_message().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "invitation_message"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(56)) goto parse_creation_time; + break; + } + + // optional uint64 creation_time = 7; + case 7: { + if (tag == 56) { + parse_creation_time: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &creation_time_))); + set_has_creation_time(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(64)) goto parse_expiration_time; + break; + } + + // optional uint64 expiration_time = 8; + case 8: { + if (tag == 64) { + parse_expiration_time: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &expiration_time_))); + set_has_expiration_time(); + } 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; + } + if ((800u <= tag && tag < 80000u)) { + DO_(_extensions_.ParseField(tag, input, default_instance_, + mutable_unknown_fields())); + continue; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:bgs.protocol.Invitation) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.Invitation) + return false; +#undef DO_ +} + +void Invitation::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.Invitation) + // required fixed64 id = 1; + if (has_id()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->id(), output); + } + + // required .bgs.protocol.Identity inviter_identity = 2; + if (has_inviter_identity()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->inviter_identity(), output); + } + + // required .bgs.protocol.Identity invitee_identity = 3; + if (has_invitee_identity()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->invitee_identity(), output); + } + + // optional string inviter_name = 4; + if (has_inviter_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->inviter_name().data(), this->inviter_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "inviter_name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 4, this->inviter_name(), output); + } + + // optional string invitee_name = 5; + if (has_invitee_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->invitee_name().data(), this->invitee_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "invitee_name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 5, this->invitee_name(), output); + } + + // optional string invitation_message = 6; + if (has_invitation_message()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->invitation_message().data(), this->invitation_message().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "invitation_message"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 6, this->invitation_message(), output); + } + + // optional uint64 creation_time = 7; + if (has_creation_time()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(7, this->creation_time(), output); + } + + // optional uint64 expiration_time = 8; + if (has_expiration_time()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(8, this->expiration_time(), output); + } + + // Extension range [100, 10000) + _extensions_.SerializeWithCachedSizes( + 100, 10000, output); + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.Invitation) +} + +::google::protobuf::uint8* Invitation::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.Invitation) + // required fixed64 id = 1; + if (has_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->id(), target); + } + + // required .bgs.protocol.Identity inviter_identity = 2; + if (has_inviter_identity()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->inviter_identity(), target); + } + + // required .bgs.protocol.Identity invitee_identity = 3; + if (has_invitee_identity()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->invitee_identity(), target); + } + + // optional string inviter_name = 4; + if (has_inviter_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->inviter_name().data(), this->inviter_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "inviter_name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->inviter_name(), target); + } + + // optional string invitee_name = 5; + if (has_invitee_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->invitee_name().data(), this->invitee_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "invitee_name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 5, this->invitee_name(), target); + } + + // optional string invitation_message = 6; + if (has_invitation_message()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->invitation_message().data(), this->invitation_message().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "invitation_message"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 6, this->invitation_message(), target); + } + + // optional uint64 creation_time = 7; + if (has_creation_time()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(7, this->creation_time(), target); + } + + // optional uint64 expiration_time = 8; + if (has_expiration_time()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(8, this->expiration_time(), target); + } + + // Extension range [100, 10000) + target = _extensions_.SerializeWithCachedSizesToArray( + 100, 10000, target); + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.Invitation) + return target; +} + +int Invitation::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed64 id = 1; + if (has_id()) { + total_size += 1 + 8; + } + + // required .bgs.protocol.Identity inviter_identity = 2; + if (has_inviter_identity()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->inviter_identity()); + } + + // required .bgs.protocol.Identity invitee_identity = 3; + if (has_invitee_identity()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->invitee_identity()); + } + + // optional string inviter_name = 4; + if (has_inviter_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->inviter_name()); + } + + // optional string invitee_name = 5; + if (has_invitee_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->invitee_name()); + } + + // optional string invitation_message = 6; + if (has_invitation_message()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->invitation_message()); + } + + // optional uint64 creation_time = 7; + if (has_creation_time()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->creation_time()); + } + + // optional uint64 expiration_time = 8; + if (has_expiration_time()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->expiration_time()); + } + + } + total_size += _extensions_.ByteSize(); + + 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 Invitation::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Invitation* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Invitation::MergeFrom(const Invitation& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_id()) { + set_id(from.id()); + } + if (from.has_inviter_identity()) { + mutable_inviter_identity()->::bgs::protocol::Identity::MergeFrom(from.inviter_identity()); + } + if (from.has_invitee_identity()) { + mutable_invitee_identity()->::bgs::protocol::Identity::MergeFrom(from.invitee_identity()); + } + if (from.has_inviter_name()) { + set_inviter_name(from.inviter_name()); + } + if (from.has_invitee_name()) { + set_invitee_name(from.invitee_name()); + } + if (from.has_invitation_message()) { + set_invitation_message(from.invitation_message()); + } + if (from.has_creation_time()) { + set_creation_time(from.creation_time()); + } + if (from.has_expiration_time()) { + set_expiration_time(from.expiration_time()); + } + } + _extensions_.MergeFrom(from._extensions_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Invitation::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Invitation::CopyFrom(const Invitation& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Invitation::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + if (has_inviter_identity()) { + if (!this->inviter_identity().IsInitialized()) return false; + } + if (has_invitee_identity()) { + if (!this->invitee_identity().IsInitialized()) return false; + } + + if (!_extensions_.IsInitialized()) return false; return true; +} + +void Invitation::Swap(Invitation* other) { + if (other != this) { + std::swap(id_, other->id_); + std::swap(inviter_identity_, other->inviter_identity_); + std::swap(invitee_identity_, other->invitee_identity_); + std::swap(inviter_name_, other->inviter_name_); + std::swap(invitee_name_, other->invitee_name_); + std::swap(invitation_message_, other->invitation_message_); + std::swap(creation_time_, other->creation_time_); + std::swap(expiration_time_, other->expiration_time_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + _extensions_.Swap(&other->_extensions_); + } +} + +::google::protobuf::Metadata Invitation::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Invitation_descriptor_; + metadata.reflection = Invitation_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int InvitationSuggestion::kChannelIdFieldNumber; +const int InvitationSuggestion::kSuggesterIdFieldNumber; +const int InvitationSuggestion::kSuggesteeIdFieldNumber; +const int InvitationSuggestion::kSuggesterNameFieldNumber; +const int InvitationSuggestion::kSuggesteeNameFieldNumber; +const int InvitationSuggestion::kSuggesterAccountIdFieldNumber; +#endif // !_MSC_VER + +InvitationSuggestion::InvitationSuggestion() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.InvitationSuggestion) +} + +void InvitationSuggestion::InitAsDefaultInstance() { + channel_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + suggester_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + suggestee_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + suggester_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +InvitationSuggestion::InvitationSuggestion(const InvitationSuggestion& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.InvitationSuggestion) +} + +void InvitationSuggestion::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + channel_id_ = NULL; + suggester_id_ = NULL; + suggestee_id_ = NULL; + suggester_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + suggestee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + suggester_account_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +InvitationSuggestion::~InvitationSuggestion() { + // @@protoc_insertion_point(destructor:bgs.protocol.InvitationSuggestion) + SharedDtor(); +} + +void InvitationSuggestion::SharedDtor() { + if (suggester_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete suggester_name_; + } + if (suggestee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete suggestee_name_; + } + if (this != default_instance_) { + delete channel_id_; + delete suggester_id_; + delete suggestee_id_; + delete suggester_account_id_; + } +} + +void InvitationSuggestion::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* InvitationSuggestion::descriptor() { + protobuf_AssignDescriptorsOnce(); + return InvitationSuggestion_descriptor_; +} + +const InvitationSuggestion& InvitationSuggestion::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_invitation_5ftypes_2eproto(); + return *default_instance_; +} + +InvitationSuggestion* InvitationSuggestion::default_instance_ = NULL; + +InvitationSuggestion* InvitationSuggestion::New() const { + return new InvitationSuggestion; +} + +void InvitationSuggestion::Clear() { + if (_has_bits_[0 / 32] & 63) { + if (has_channel_id()) { + if (channel_id_ != NULL) channel_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_suggester_id()) { + if (suggester_id_ != NULL) suggester_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_suggestee_id()) { + if (suggestee_id_ != NULL) suggestee_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_suggester_name()) { + if (suggester_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + suggester_name_->clear(); + } + } + if (has_suggestee_name()) { + if (suggestee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + suggestee_name_->clear(); + } + } + if (has_suggester_account_id()) { + if (suggester_account_id_ != NULL) suggester_account_id_->::bgs::protocol::EntityId::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool InvitationSuggestion::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.InvitationSuggestion) + 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 .bgs.protocol.EntityId channel_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_channel_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_suggester_id; + break; + } + + // required .bgs.protocol.EntityId suggester_id = 2; + case 2: { + if (tag == 18) { + parse_suggester_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_suggester_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_suggestee_id; + break; + } + + // required .bgs.protocol.EntityId suggestee_id = 3; + case 3: { + if (tag == 26) { + parse_suggestee_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_suggestee_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_suggester_name; + break; + } + + // optional string suggester_name = 4; + case 4: { + if (tag == 34) { + parse_suggester_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_suggester_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->suggester_name().data(), this->suggester_name().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "suggester_name"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_suggestee_name; + break; + } + + // optional string suggestee_name = 5; + case 5: { + if (tag == 42) { + parse_suggestee_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_suggestee_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->suggestee_name().data(), this->suggestee_name().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "suggestee_name"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_suggester_account_id; + break; + } + + // optional .bgs.protocol.EntityId suggester_account_id = 6; + case 6: { + if (tag == 50) { + parse_suggester_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_suggester_account_id())); + } 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:bgs.protocol.InvitationSuggestion) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.InvitationSuggestion) + return false; +#undef DO_ +} + +void InvitationSuggestion::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.InvitationSuggestion) + // optional .bgs.protocol.EntityId channel_id = 1; + if (has_channel_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->channel_id(), output); + } + + // required .bgs.protocol.EntityId suggester_id = 2; + if (has_suggester_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->suggester_id(), output); + } + + // required .bgs.protocol.EntityId suggestee_id = 3; + if (has_suggestee_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->suggestee_id(), output); + } + + // optional string suggester_name = 4; + if (has_suggester_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->suggester_name().data(), this->suggester_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "suggester_name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 4, this->suggester_name(), output); + } + + // optional string suggestee_name = 5; + if (has_suggestee_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->suggestee_name().data(), this->suggestee_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "suggestee_name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 5, this->suggestee_name(), output); + } + + // optional .bgs.protocol.EntityId suggester_account_id = 6; + if (has_suggester_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, this->suggester_account_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.InvitationSuggestion) +} + +::google::protobuf::uint8* InvitationSuggestion::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.InvitationSuggestion) + // optional .bgs.protocol.EntityId channel_id = 1; + if (has_channel_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->channel_id(), target); + } + + // required .bgs.protocol.EntityId suggester_id = 2; + if (has_suggester_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->suggester_id(), target); + } + + // required .bgs.protocol.EntityId suggestee_id = 3; + if (has_suggestee_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->suggestee_id(), target); + } + + // optional string suggester_name = 4; + if (has_suggester_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->suggester_name().data(), this->suggester_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "suggester_name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->suggester_name(), target); + } + + // optional string suggestee_name = 5; + if (has_suggestee_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->suggestee_name().data(), this->suggestee_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "suggestee_name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 5, this->suggestee_name(), target); + } + + // optional .bgs.protocol.EntityId suggester_account_id = 6; + if (has_suggester_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 6, this->suggester_account_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.InvitationSuggestion) + return target; +} + +int InvitationSuggestion::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId channel_id = 1; + if (has_channel_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->channel_id()); + } + + // required .bgs.protocol.EntityId suggester_id = 2; + if (has_suggester_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->suggester_id()); + } + + // required .bgs.protocol.EntityId suggestee_id = 3; + if (has_suggestee_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->suggestee_id()); + } + + // optional string suggester_name = 4; + if (has_suggester_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->suggester_name()); + } + + // optional string suggestee_name = 5; + if (has_suggestee_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->suggestee_name()); + } + + // optional .bgs.protocol.EntityId suggester_account_id = 6; + if (has_suggester_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->suggester_account_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void InvitationSuggestion::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const InvitationSuggestion* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void InvitationSuggestion::MergeFrom(const InvitationSuggestion& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_channel_id()) { + mutable_channel_id()->::bgs::protocol::EntityId::MergeFrom(from.channel_id()); + } + if (from.has_suggester_id()) { + mutable_suggester_id()->::bgs::protocol::EntityId::MergeFrom(from.suggester_id()); + } + if (from.has_suggestee_id()) { + mutable_suggestee_id()->::bgs::protocol::EntityId::MergeFrom(from.suggestee_id()); + } + if (from.has_suggester_name()) { + set_suggester_name(from.suggester_name()); + } + if (from.has_suggestee_name()) { + set_suggestee_name(from.suggestee_name()); + } + if (from.has_suggester_account_id()) { + mutable_suggester_account_id()->::bgs::protocol::EntityId::MergeFrom(from.suggester_account_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void InvitationSuggestion::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void InvitationSuggestion::CopyFrom(const InvitationSuggestion& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool InvitationSuggestion::IsInitialized() const { + if ((_has_bits_[0] & 0x00000006) != 0x00000006) return false; + + if (has_channel_id()) { + if (!this->channel_id().IsInitialized()) return false; + } + if (has_suggester_id()) { + if (!this->suggester_id().IsInitialized()) return false; + } + if (has_suggestee_id()) { + if (!this->suggestee_id().IsInitialized()) return false; + } + if (has_suggester_account_id()) { + if (!this->suggester_account_id().IsInitialized()) return false; + } + return true; +} + +void InvitationSuggestion::Swap(InvitationSuggestion* other) { + if (other != this) { + std::swap(channel_id_, other->channel_id_); + std::swap(suggester_id_, other->suggester_id_); + std::swap(suggestee_id_, other->suggestee_id_); + std::swap(suggester_name_, other->suggester_name_); + std::swap(suggestee_name_, other->suggestee_name_); + std::swap(suggester_account_id_, other->suggester_account_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata InvitationSuggestion::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = InvitationSuggestion_descriptor_; + metadata.reflection = InvitationSuggestion_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int InvitationTarget::kIdentityFieldNumber; +const int InvitationTarget::kEmailFieldNumber; +const int InvitationTarget::kBattleTagFieldNumber; +#endif // !_MSC_VER + +InvitationTarget::InvitationTarget() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.InvitationTarget) +} + +void InvitationTarget::InitAsDefaultInstance() { + identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance()); +} + +InvitationTarget::InvitationTarget(const InvitationTarget& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.InvitationTarget) +} + +void InvitationTarget::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + identity_ = NULL; + email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +InvitationTarget::~InvitationTarget() { + // @@protoc_insertion_point(destructor:bgs.protocol.InvitationTarget) + SharedDtor(); +} + +void InvitationTarget::SharedDtor() { + if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete email_; + } + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete battle_tag_; + } + if (this != default_instance_) { + delete identity_; + } +} + +void InvitationTarget::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* InvitationTarget::descriptor() { + protobuf_AssignDescriptorsOnce(); + return InvitationTarget_descriptor_; +} + +const InvitationTarget& InvitationTarget::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_invitation_5ftypes_2eproto(); + return *default_instance_; +} + +InvitationTarget* InvitationTarget::default_instance_ = NULL; + +InvitationTarget* InvitationTarget::New() const { + return new InvitationTarget; +} + +void InvitationTarget::Clear() { + _extensions_.Clear(); + if (_has_bits_[0 / 32] & 7) { + if (has_identity()) { + if (identity_ != NULL) identity_->::bgs::protocol::Identity::Clear(); + } + if (has_email()) { + if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_->clear(); + } + } + if (has_battle_tag()) { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool InvitationTarget::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.InvitationTarget) + 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 .bgs.protocol.Identity identity = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_identity())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_email; + break; + } + + // optional string email = 2; + case 2: { + if (tag == 18) { + parse_email: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_email())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->email().data(), this->email().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "email"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_battle_tag; + break; + } + + // optional string battle_tag = 3; + case 3: { + if (tag == 26) { + parse_battle_tag: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_battle_tag())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->battle_tag().data(), this->battle_tag().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "battle_tag"); + } 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; + } + if ((800u <= tag && tag < 80000u)) { + DO_(_extensions_.ParseField(tag, input, default_instance_, + mutable_unknown_fields())); + continue; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:bgs.protocol.InvitationTarget) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.InvitationTarget) + return false; +#undef DO_ +} + +void InvitationTarget::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.InvitationTarget) + // optional .bgs.protocol.Identity identity = 1; + if (has_identity()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->identity(), output); + } + + // optional string email = 2; + if (has_email()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->email().data(), this->email().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "email"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->email(), output); + } + + // optional string battle_tag = 3; + if (has_battle_tag()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->battle_tag().data(), this->battle_tag().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "battle_tag"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->battle_tag(), output); + } + + // Extension range [100, 10000) + _extensions_.SerializeWithCachedSizes( + 100, 10000, output); + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.InvitationTarget) +} + +::google::protobuf::uint8* InvitationTarget::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.InvitationTarget) + // optional .bgs.protocol.Identity identity = 1; + if (has_identity()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->identity(), target); + } + + // optional string email = 2; + if (has_email()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->email().data(), this->email().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "email"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->email(), target); + } + + // optional string battle_tag = 3; + if (has_battle_tag()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->battle_tag().data(), this->battle_tag().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "battle_tag"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->battle_tag(), target); + } + + // Extension range [100, 10000) + target = _extensions_.SerializeWithCachedSizesToArray( + 100, 10000, target); + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.InvitationTarget) + return target; +} + +int InvitationTarget::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.Identity identity = 1; + if (has_identity()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->identity()); + } + + // optional string email = 2; + if (has_email()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->email()); + } + + // optional string battle_tag = 3; + if (has_battle_tag()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->battle_tag()); + } + + } + total_size += _extensions_.ByteSize(); + + 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 InvitationTarget::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const InvitationTarget* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void InvitationTarget::MergeFrom(const InvitationTarget& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_identity()) { + mutable_identity()->::bgs::protocol::Identity::MergeFrom(from.identity()); + } + if (from.has_email()) { + set_email(from.email()); + } + if (from.has_battle_tag()) { + set_battle_tag(from.battle_tag()); + } + } + _extensions_.MergeFrom(from._extensions_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void InvitationTarget::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void InvitationTarget::CopyFrom(const InvitationTarget& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool InvitationTarget::IsInitialized() const { + + if (has_identity()) { + if (!this->identity().IsInitialized()) return false; + } + + if (!_extensions_.IsInitialized()) return false; return true; +} + +void InvitationTarget::Swap(InvitationTarget* other) { + if (other != this) { + std::swap(identity_, other->identity_); + std::swap(email_, other->email_); + std::swap(battle_tag_, other->battle_tag_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + _extensions_.Swap(&other->_extensions_); + } +} + +::google::protobuf::Metadata InvitationTarget::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = InvitationTarget_descriptor_; + metadata.reflection = InvitationTarget_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int InvitationParams::kInvitationMessageFieldNumber; +const int InvitationParams::kExpirationTimeFieldNumber; +#endif // !_MSC_VER + +InvitationParams::InvitationParams() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.InvitationParams) +} + +void InvitationParams::InitAsDefaultInstance() { +} + +InvitationParams::InvitationParams(const InvitationParams& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.InvitationParams) +} + +void InvitationParams::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + invitation_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + expiration_time_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +InvitationParams::~InvitationParams() { + // @@protoc_insertion_point(destructor:bgs.protocol.InvitationParams) + SharedDtor(); +} + +void InvitationParams::SharedDtor() { + if (invitation_message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete invitation_message_; + } + if (this != default_instance_) { + } +} + +void InvitationParams::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* InvitationParams::descriptor() { + protobuf_AssignDescriptorsOnce(); + return InvitationParams_descriptor_; +} + +const InvitationParams& InvitationParams::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_invitation_5ftypes_2eproto(); + return *default_instance_; +} + +InvitationParams* InvitationParams::default_instance_ = NULL; + +InvitationParams* InvitationParams::New() const { + return new InvitationParams; +} + +void InvitationParams::Clear() { + _extensions_.Clear(); + if (_has_bits_[0 / 32] & 3) { + if (has_invitation_message()) { + if (invitation_message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitation_message_->clear(); + } + } + expiration_time_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool InvitationParams::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.InvitationParams) + 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 invitation_message = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_invitation_message())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->invitation_message().data(), this->invitation_message().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "invitation_message"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_expiration_time; + break; + } + + // optional uint64 expiration_time = 2 [default = 0]; + case 2: { + if (tag == 16) { + parse_expiration_time: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &expiration_time_))); + set_has_expiration_time(); + } 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; + } + if ((800u <= tag && tag < 80000u)) { + DO_(_extensions_.ParseField(tag, input, default_instance_, + mutable_unknown_fields())); + continue; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:bgs.protocol.InvitationParams) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.InvitationParams) + return false; +#undef DO_ +} + +void InvitationParams::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.InvitationParams) + // optional string invitation_message = 1; + if (has_invitation_message()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->invitation_message().data(), this->invitation_message().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "invitation_message"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->invitation_message(), output); + } + + // optional uint64 expiration_time = 2 [default = 0]; + if (has_expiration_time()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->expiration_time(), output); + } + + // Extension range [100, 10000) + _extensions_.SerializeWithCachedSizes( + 100, 10000, output); + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.InvitationParams) +} + +::google::protobuf::uint8* InvitationParams::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.InvitationParams) + // optional string invitation_message = 1; + if (has_invitation_message()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->invitation_message().data(), this->invitation_message().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "invitation_message"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->invitation_message(), target); + } + + // optional uint64 expiration_time = 2 [default = 0]; + if (has_expiration_time()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->expiration_time(), target); + } + + // Extension range [100, 10000) + target = _extensions_.SerializeWithCachedSizesToArray( + 100, 10000, target); + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.InvitationParams) + return target; +} + +int InvitationParams::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional string invitation_message = 1; + if (has_invitation_message()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->invitation_message()); + } + + // optional uint64 expiration_time = 2 [default = 0]; + if (has_expiration_time()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->expiration_time()); + } + + } + total_size += _extensions_.ByteSize(); + + 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 InvitationParams::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const InvitationParams* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void InvitationParams::MergeFrom(const InvitationParams& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_invitation_message()) { + set_invitation_message(from.invitation_message()); + } + if (from.has_expiration_time()) { + set_expiration_time(from.expiration_time()); + } + } + _extensions_.MergeFrom(from._extensions_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void InvitationParams::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void InvitationParams::CopyFrom(const InvitationParams& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool InvitationParams::IsInitialized() const { + + + if (!_extensions_.IsInitialized()) return false; return true; +} + +void InvitationParams::Swap(InvitationParams* other) { + if (other != this) { + std::swap(invitation_message_, other->invitation_message_); + std::swap(expiration_time_, other->expiration_time_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + _extensions_.Swap(&other->_extensions_); + } +} + +::google::protobuf::Metadata InvitationParams::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = InvitationParams_descriptor_; + metadata.reflection = InvitationParams_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int SendInvitationRequest::kAgentIdentityFieldNumber; +const int SendInvitationRequest::kTargetIdFieldNumber; +const int SendInvitationRequest::kParamsFieldNumber; +const int SendInvitationRequest::kAgentInfoFieldNumber; +const int SendInvitationRequest::kTargetFieldNumber; +#endif // !_MSC_VER + +SendInvitationRequest::SendInvitationRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.SendInvitationRequest) +} + +void SendInvitationRequest::InitAsDefaultInstance() { + agent_identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance()); + target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + params_ = const_cast< ::bgs::protocol::InvitationParams*>(&::bgs::protocol::InvitationParams::default_instance()); + agent_info_ = const_cast< ::bgs::protocol::AccountInfo*>(&::bgs::protocol::AccountInfo::default_instance()); + target_ = const_cast< ::bgs::protocol::InvitationTarget*>(&::bgs::protocol::InvitationTarget::default_instance()); +} + +SendInvitationRequest::SendInvitationRequest(const SendInvitationRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.SendInvitationRequest) +} + +void SendInvitationRequest::SharedCtor() { + _cached_size_ = 0; + agent_identity_ = NULL; + target_id_ = NULL; + params_ = NULL; + agent_info_ = NULL; + target_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +SendInvitationRequest::~SendInvitationRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.SendInvitationRequest) + SharedDtor(); +} + +void SendInvitationRequest::SharedDtor() { + if (this != default_instance_) { + delete agent_identity_; + delete target_id_; + delete params_; + delete agent_info_; + delete target_; + } +} + +void SendInvitationRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SendInvitationRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SendInvitationRequest_descriptor_; +} + +const SendInvitationRequest& SendInvitationRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_invitation_5ftypes_2eproto(); + return *default_instance_; +} + +SendInvitationRequest* SendInvitationRequest::default_instance_ = NULL; + +SendInvitationRequest* SendInvitationRequest::New() const { + return new SendInvitationRequest; +} + +void SendInvitationRequest::Clear() { + if (_has_bits_[0 / 32] & 31) { + if (has_agent_identity()) { + if (agent_identity_ != NULL) agent_identity_->::bgs::protocol::Identity::Clear(); + } + if (has_target_id()) { + if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_params()) { + if (params_ != NULL) params_->::bgs::protocol::InvitationParams::Clear(); + } + if (has_agent_info()) { + if (agent_info_ != NULL) agent_info_->::bgs::protocol::AccountInfo::Clear(); + } + if (has_target()) { + if (target_ != NULL) target_->::bgs::protocol::InvitationTarget::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool SendInvitationRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.SendInvitationRequest) + 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 .bgs.protocol.Identity agent_identity = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_identity())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_target_id; + break; + } + + // required .bgs.protocol.EntityId target_id = 2 [deprecated = true]; + case 2: { + if (tag == 18) { + parse_target_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_target_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_params; + break; + } + + // required .bgs.protocol.InvitationParams params = 3; + case 3: { + if (tag == 26) { + parse_params: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_params())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_agent_info; + break; + } + + // optional .bgs.protocol.AccountInfo agent_info = 4; + case 4: { + if (tag == 34) { + parse_agent_info: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_info())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_target; + break; + } + + // optional .bgs.protocol.InvitationTarget target = 5; + case 5: { + if (tag == 42) { + parse_target: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_target())); + } 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:bgs.protocol.SendInvitationRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.SendInvitationRequest) + return false; +#undef DO_ +} + +void SendInvitationRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.SendInvitationRequest) + // optional .bgs.protocol.Identity agent_identity = 1; + if (has_agent_identity()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_identity(), output); + } + + // required .bgs.protocol.EntityId target_id = 2 [deprecated = true]; + if (has_target_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->target_id(), output); + } + + // required .bgs.protocol.InvitationParams params = 3; + if (has_params()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->params(), output); + } + + // optional .bgs.protocol.AccountInfo agent_info = 4; + if (has_agent_info()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->agent_info(), output); + } + + // optional .bgs.protocol.InvitationTarget target = 5; + if (has_target()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, this->target(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.SendInvitationRequest) +} + +::google::protobuf::uint8* SendInvitationRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.SendInvitationRequest) + // optional .bgs.protocol.Identity agent_identity = 1; + if (has_agent_identity()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_identity(), target); + } + + // required .bgs.protocol.EntityId target_id = 2 [deprecated = true]; + if (has_target_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->target_id(), target); + } + + // required .bgs.protocol.InvitationParams params = 3; + if (has_params()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->params(), target); + } + + // optional .bgs.protocol.AccountInfo agent_info = 4; + if (has_agent_info()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->agent_info(), target); + } + + // optional .bgs.protocol.InvitationTarget target = 5; + if (has_target()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 5, this->target(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.SendInvitationRequest) + return target; +} + +int SendInvitationRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.Identity agent_identity = 1; + if (has_agent_identity()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_identity()); + } + + // required .bgs.protocol.EntityId target_id = 2 [deprecated = true]; + if (has_target_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->target_id()); + } + + // required .bgs.protocol.InvitationParams params = 3; + if (has_params()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->params()); + } + + // optional .bgs.protocol.AccountInfo agent_info = 4; + if (has_agent_info()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_info()); + } + + // optional .bgs.protocol.InvitationTarget target = 5; + if (has_target()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->target()); + } + + } + 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 SendInvitationRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const SendInvitationRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void SendInvitationRequest::MergeFrom(const SendInvitationRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_identity()) { + mutable_agent_identity()->::bgs::protocol::Identity::MergeFrom(from.agent_identity()); + } + if (from.has_target_id()) { + mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id()); + } + if (from.has_params()) { + mutable_params()->::bgs::protocol::InvitationParams::MergeFrom(from.params()); + } + if (from.has_agent_info()) { + mutable_agent_info()->::bgs::protocol::AccountInfo::MergeFrom(from.agent_info()); + } + if (from.has_target()) { + mutable_target()->::bgs::protocol::InvitationTarget::MergeFrom(from.target()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void SendInvitationRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SendInvitationRequest::CopyFrom(const SendInvitationRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SendInvitationRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000006) != 0x00000006) return false; + + if (has_agent_identity()) { + if (!this->agent_identity().IsInitialized()) return false; + } + if (has_target_id()) { + if (!this->target_id().IsInitialized()) return false; + } + if (has_params()) { + if (!this->params().IsInitialized()) return false; + } + if (has_agent_info()) { + if (!this->agent_info().IsInitialized()) return false; + } + if (has_target()) { + if (!this->target().IsInitialized()) return false; + } + return true; +} + +void SendInvitationRequest::Swap(SendInvitationRequest* other) { + if (other != this) { + std::swap(agent_identity_, other->agent_identity_); + std::swap(target_id_, other->target_id_); + std::swap(params_, other->params_); + std::swap(agent_info_, other->agent_info_); + std::swap(target_, other->target_); + 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 SendInvitationRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SendInvitationRequest_descriptor_; + metadata.reflection = SendInvitationRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int SendInvitationResponse::kInvitationFieldNumber; +#endif // !_MSC_VER + +SendInvitationResponse::SendInvitationResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.SendInvitationResponse) +} + +void SendInvitationResponse::InitAsDefaultInstance() { + invitation_ = const_cast< ::bgs::protocol::Invitation*>(&::bgs::protocol::Invitation::default_instance()); +} + +SendInvitationResponse::SendInvitationResponse(const SendInvitationResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.SendInvitationResponse) +} + +void SendInvitationResponse::SharedCtor() { + _cached_size_ = 0; + invitation_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +SendInvitationResponse::~SendInvitationResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.SendInvitationResponse) + SharedDtor(); +} + +void SendInvitationResponse::SharedDtor() { + if (this != default_instance_) { + delete invitation_; + } +} + +void SendInvitationResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SendInvitationResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SendInvitationResponse_descriptor_; +} + +const SendInvitationResponse& SendInvitationResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_invitation_5ftypes_2eproto(); + return *default_instance_; +} + +SendInvitationResponse* SendInvitationResponse::default_instance_ = NULL; + +SendInvitationResponse* SendInvitationResponse::New() const { + return new SendInvitationResponse; +} + +void SendInvitationResponse::Clear() { + if (has_invitation()) { + if (invitation_ != NULL) invitation_->::bgs::protocol::Invitation::Clear(); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool SendInvitationResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.SendInvitationResponse) + 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 .bgs.protocol.Invitation invitation = 2; + case 2: { + if (tag == 18) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_invitation())); + } 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:bgs.protocol.SendInvitationResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.SendInvitationResponse) + return false; +#undef DO_ +} + +void SendInvitationResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.SendInvitationResponse) + // optional .bgs.protocol.Invitation invitation = 2; + if (has_invitation()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->invitation(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.SendInvitationResponse) +} + +::google::protobuf::uint8* SendInvitationResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.SendInvitationResponse) + // optional .bgs.protocol.Invitation invitation = 2; + if (has_invitation()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->invitation(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.SendInvitationResponse) + return target; +} + +int SendInvitationResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.Invitation invitation = 2; + if (has_invitation()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->invitation()); + } + + } + 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 SendInvitationResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const SendInvitationResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void SendInvitationResponse::MergeFrom(const SendInvitationResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_invitation()) { + mutable_invitation()->::bgs::protocol::Invitation::MergeFrom(from.invitation()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void SendInvitationResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SendInvitationResponse::CopyFrom(const SendInvitationResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SendInvitationResponse::IsInitialized() const { + + if (has_invitation()) { + if (!this->invitation().IsInitialized()) return false; + } + return true; +} + +void SendInvitationResponse::Swap(SendInvitationResponse* other) { + if (other != this) { + std::swap(invitation_, other->invitation_); + 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 SendInvitationResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SendInvitationResponse_descriptor_; + metadata.reflection = SendInvitationResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int UpdateInvitationRequest::kAgentIdentityFieldNumber; +const int UpdateInvitationRequest::kInvitationIdFieldNumber; +const int UpdateInvitationRequest::kParamsFieldNumber; +#endif // !_MSC_VER + +UpdateInvitationRequest::UpdateInvitationRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.UpdateInvitationRequest) +} + +void UpdateInvitationRequest::InitAsDefaultInstance() { + agent_identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance()); + params_ = const_cast< ::bgs::protocol::InvitationParams*>(&::bgs::protocol::InvitationParams::default_instance()); +} + +UpdateInvitationRequest::UpdateInvitationRequest(const UpdateInvitationRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.UpdateInvitationRequest) +} + +void UpdateInvitationRequest::SharedCtor() { + _cached_size_ = 0; + agent_identity_ = NULL; + invitation_id_ = GOOGLE_ULONGLONG(0); + params_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +UpdateInvitationRequest::~UpdateInvitationRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.UpdateInvitationRequest) + SharedDtor(); +} + +void UpdateInvitationRequest::SharedDtor() { + if (this != default_instance_) { + delete agent_identity_; + delete params_; + } +} + +void UpdateInvitationRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* UpdateInvitationRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return UpdateInvitationRequest_descriptor_; +} + +const UpdateInvitationRequest& UpdateInvitationRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_invitation_5ftypes_2eproto(); + return *default_instance_; +} + +UpdateInvitationRequest* UpdateInvitationRequest::default_instance_ = NULL; + +UpdateInvitationRequest* UpdateInvitationRequest::New() const { + return new UpdateInvitationRequest; +} + +void UpdateInvitationRequest::Clear() { + if (_has_bits_[0 / 32] & 7) { + if (has_agent_identity()) { + if (agent_identity_ != NULL) agent_identity_->::bgs::protocol::Identity::Clear(); + } + invitation_id_ = GOOGLE_ULONGLONG(0); + if (has_params()) { + if (params_ != NULL) params_->::bgs::protocol::InvitationParams::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool UpdateInvitationRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.UpdateInvitationRequest) + 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 .bgs.protocol.Identity agent_identity = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_identity())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(17)) goto parse_invitation_id; + break; + } + + // required fixed64 invitation_id = 2; + case 2: { + if (tag == 17) { + parse_invitation_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &invitation_id_))); + set_has_invitation_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_params; + break; + } + + // required .bgs.protocol.InvitationParams params = 3; + case 3: { + if (tag == 26) { + parse_params: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_params())); + } 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:bgs.protocol.UpdateInvitationRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.UpdateInvitationRequest) + return false; +#undef DO_ +} + +void UpdateInvitationRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.UpdateInvitationRequest) + // optional .bgs.protocol.Identity agent_identity = 1; + if (has_agent_identity()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_identity(), output); + } + + // required fixed64 invitation_id = 2; + if (has_invitation_id()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->invitation_id(), output); + } + + // required .bgs.protocol.InvitationParams params = 3; + if (has_params()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->params(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.UpdateInvitationRequest) +} + +::google::protobuf::uint8* UpdateInvitationRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.UpdateInvitationRequest) + // optional .bgs.protocol.Identity agent_identity = 1; + if (has_agent_identity()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_identity(), target); + } + + // required fixed64 invitation_id = 2; + if (has_invitation_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->invitation_id(), target); + } + + // required .bgs.protocol.InvitationParams params = 3; + if (has_params()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->params(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.UpdateInvitationRequest) + return target; +} + +int UpdateInvitationRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.Identity agent_identity = 1; + if (has_agent_identity()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_identity()); + } + + // required fixed64 invitation_id = 2; + if (has_invitation_id()) { + total_size += 1 + 8; + } + + // required .bgs.protocol.InvitationParams params = 3; + if (has_params()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->params()); + } + + } + 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 UpdateInvitationRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const UpdateInvitationRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void UpdateInvitationRequest::MergeFrom(const UpdateInvitationRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_identity()) { + mutable_agent_identity()->::bgs::protocol::Identity::MergeFrom(from.agent_identity()); + } + if (from.has_invitation_id()) { + set_invitation_id(from.invitation_id()); + } + if (from.has_params()) { + mutable_params()->::bgs::protocol::InvitationParams::MergeFrom(from.params()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void UpdateInvitationRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void UpdateInvitationRequest::CopyFrom(const UpdateInvitationRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool UpdateInvitationRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000006) != 0x00000006) return false; + + if (has_agent_identity()) { + if (!this->agent_identity().IsInitialized()) return false; + } + if (has_params()) { + if (!this->params().IsInitialized()) return false; + } + return true; +} + +void UpdateInvitationRequest::Swap(UpdateInvitationRequest* other) { + if (other != this) { + std::swap(agent_identity_, other->agent_identity_); + std::swap(invitation_id_, other->invitation_id_); + std::swap(params_, other->params_); + 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 UpdateInvitationRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = UpdateInvitationRequest_descriptor_; + metadata.reflection = UpdateInvitationRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GenericInvitationRequest::kAgentIdFieldNumber; +const int GenericInvitationRequest::kTargetIdFieldNumber; +const int GenericInvitationRequest::kInvitationIdFieldNumber; +const int GenericInvitationRequest::kInviteeNameFieldNumber; +const int GenericInvitationRequest::kInviterNameFieldNumber; +const int GenericInvitationRequest::kPreviousRoleFieldNumber; +const int GenericInvitationRequest::kDesiredRoleFieldNumber; +const int GenericInvitationRequest::kReasonFieldNumber; +#endif // !_MSC_VER + +GenericInvitationRequest::GenericInvitationRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.GenericInvitationRequest) +} + +void GenericInvitationRequest::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +GenericInvitationRequest::GenericInvitationRequest(const GenericInvitationRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.GenericInvitationRequest) +} + +void GenericInvitationRequest::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + agent_id_ = NULL; + target_id_ = NULL; + invitation_id_ = GOOGLE_ULONGLONG(0); + invitee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + inviter_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + reason_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GenericInvitationRequest::~GenericInvitationRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.GenericInvitationRequest) + SharedDtor(); +} + +void GenericInvitationRequest::SharedDtor() { + if (invitee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete invitee_name_; + } + if (inviter_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete inviter_name_; + } + if (this != default_instance_) { + delete agent_id_; + delete target_id_; + } +} + +void GenericInvitationRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GenericInvitationRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GenericInvitationRequest_descriptor_; +} + +const GenericInvitationRequest& GenericInvitationRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_invitation_5ftypes_2eproto(); + return *default_instance_; +} + +GenericInvitationRequest* GenericInvitationRequest::default_instance_ = NULL; + +GenericInvitationRequest* GenericInvitationRequest::New() const { + return new GenericInvitationRequest; +} + +void GenericInvitationRequest::Clear() { + if (_has_bits_[0 / 32] & 159) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_target_id()) { + if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear(); + } + invitation_id_ = GOOGLE_ULONGLONG(0); + if (has_invitee_name()) { + if (invitee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitee_name_->clear(); + } + } + if (has_inviter_name()) { + if (inviter_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + inviter_name_->clear(); + } + } + reason_ = 0u; + } + previous_role_.Clear(); + desired_role_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GenericInvitationRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.GenericInvitationRequest) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_target_id; + break; + } + + // optional .bgs.protocol.EntityId target_id = 2; + case 2: { + if (tag == 18) { + parse_target_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_target_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(25)) goto parse_invitation_id; + break; + } + + // required fixed64 invitation_id = 3; + case 3: { + if (tag == 25) { + parse_invitation_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &invitation_id_))); + set_has_invitation_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_invitee_name; + break; + } + + // optional string invitee_name = 4; + case 4: { + if (tag == 34) { + parse_invitee_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_invitee_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->invitee_name().data(), this->invitee_name().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "invitee_name"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_inviter_name; + break; + } + + // optional string inviter_name = 5; + case 5: { + if (tag == 42) { + parse_inviter_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_inviter_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->inviter_name().data(), this->inviter_name().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "inviter_name"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_previous_role; + break; + } + + // repeated uint32 previous_role = 6 [packed = true]; + case 6: { + if (tag == 50) { + parse_previous_role: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_previous_role()))); + } else if (tag == 48) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 50, input, this->mutable_previous_role()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(58)) goto parse_desired_role; + break; + } + + // repeated uint32 desired_role = 7 [packed = true]; + case 7: { + if (tag == 58) { + parse_desired_role: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_desired_role()))); + } else if (tag == 56) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 58, input, this->mutable_desired_role()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(64)) goto parse_reason; + break; + } + + // optional uint32 reason = 8; + case 8: { + if (tag == 64) { + parse_reason: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &reason_))); + set_has_reason(); + } 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:bgs.protocol.GenericInvitationRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.GenericInvitationRequest) + return false; +#undef DO_ +} + +void GenericInvitationRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.GenericInvitationRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // optional .bgs.protocol.EntityId target_id = 2; + if (has_target_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->target_id(), output); + } + + // required fixed64 invitation_id = 3; + if (has_invitation_id()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->invitation_id(), output); + } + + // optional string invitee_name = 4; + if (has_invitee_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->invitee_name().data(), this->invitee_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "invitee_name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 4, this->invitee_name(), output); + } + + // optional string inviter_name = 5; + if (has_inviter_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->inviter_name().data(), this->inviter_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "inviter_name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 5, this->inviter_name(), output); + } + + // repeated uint32 previous_role = 6 [packed = true]; + if (this->previous_role_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(6, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_previous_role_cached_byte_size_); + } + for (int i = 0; i < this->previous_role_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag( + this->previous_role(i), output); + } + + // repeated uint32 desired_role = 7 [packed = true]; + if (this->desired_role_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(7, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_desired_role_cached_byte_size_); + } + for (int i = 0; i < this->desired_role_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag( + this->desired_role(i), output); + } + + // optional uint32 reason = 8; + if (has_reason()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(8, this->reason(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.GenericInvitationRequest) +} + +::google::protobuf::uint8* GenericInvitationRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.GenericInvitationRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // optional .bgs.protocol.EntityId target_id = 2; + if (has_target_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->target_id(), target); + } + + // required fixed64 invitation_id = 3; + if (has_invitation_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->invitation_id(), target); + } + + // optional string invitee_name = 4; + if (has_invitee_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->invitee_name().data(), this->invitee_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "invitee_name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->invitee_name(), target); + } + + // optional string inviter_name = 5; + if (has_inviter_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->inviter_name().data(), this->inviter_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "inviter_name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 5, this->inviter_name(), target); + } + + // repeated uint32 previous_role = 6 [packed = true]; + if (this->previous_role_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 6, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _previous_role_cached_byte_size_, target); + } + for (int i = 0; i < this->previous_role_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32NoTagToArray(this->previous_role(i), target); + } + + // repeated uint32 desired_role = 7 [packed = true]; + if (this->desired_role_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 7, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _desired_role_cached_byte_size_, target); + } + for (int i = 0; i < this->desired_role_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32NoTagToArray(this->desired_role(i), target); + } + + // optional uint32 reason = 8; + if (has_reason()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(8, this->reason(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.GenericInvitationRequest) + return target; +} + +int GenericInvitationRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // optional .bgs.protocol.EntityId target_id = 2; + if (has_target_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->target_id()); + } + + // required fixed64 invitation_id = 3; + if (has_invitation_id()) { + total_size += 1 + 8; + } + + // optional string invitee_name = 4; + if (has_invitee_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->invitee_name()); + } + + // optional string inviter_name = 5; + if (has_inviter_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->inviter_name()); + } + + // optional uint32 reason = 8; + if (has_reason()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->reason()); + } + + } + // repeated uint32 previous_role = 6 [packed = true]; + { + int data_size = 0; + for (int i = 0; i < this->previous_role_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->previous_role(i)); + } + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _previous_role_cached_byte_size_ = data_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + // repeated uint32 desired_role = 7 [packed = true]; + { + int data_size = 0; + for (int i = 0; i < this->desired_role_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->desired_role(i)); + } + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _desired_role_cached_byte_size_ = data_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_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 GenericInvitationRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GenericInvitationRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GenericInvitationRequest::MergeFrom(const GenericInvitationRequest& from) { + GOOGLE_CHECK_NE(&from, this); + previous_role_.MergeFrom(from.previous_role_); + desired_role_.MergeFrom(from.desired_role_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_target_id()) { + mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id()); + } + if (from.has_invitation_id()) { + set_invitation_id(from.invitation_id()); + } + if (from.has_invitee_name()) { + set_invitee_name(from.invitee_name()); + } + if (from.has_inviter_name()) { + set_inviter_name(from.inviter_name()); + } + if (from.has_reason()) { + set_reason(from.reason()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GenericInvitationRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GenericInvitationRequest::CopyFrom(const GenericInvitationRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GenericInvitationRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000004) != 0x00000004) return false; + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + if (has_target_id()) { + if (!this->target_id().IsInitialized()) return false; + } + return true; +} + +void GenericInvitationRequest::Swap(GenericInvitationRequest* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + std::swap(target_id_, other->target_id_); + std::swap(invitation_id_, other->invitation_id_); + std::swap(invitee_name_, other->invitee_name_); + std::swap(inviter_name_, other->inviter_name_); + previous_role_.Swap(&other->previous_role_); + desired_role_.Swap(&other->desired_role_); + std::swap(reason_, other->reason_); + 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 GenericInvitationRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GenericInvitationRequest_descriptor_; + metadata.reflection = GenericInvitationRequest_reflection_; + return metadata; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/invitation_types.pb.h b/src/server/proto/Client/invitation_types.pb.h new file mode 100644 index 00000000000..394e2ffd17f --- /dev/null +++ b/src/server/proto/Client/invitation_types.pb.h @@ -0,0 +1,2801 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: invitation_types.proto + +#ifndef PROTOBUF_invitation_5ftypes_2eproto__INCLUDED +#define PROTOBUF_invitation_5ftypes_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include "entity_types.pb.h" +#include "Define.h" // for TRINITY_SHARED_API +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_invitation_5ftypes_2eproto(); +void protobuf_AssignDesc_invitation_5ftypes_2eproto(); +void protobuf_ShutdownFile_invitation_5ftypes_2eproto(); + +class Invitation; +class InvitationSuggestion; +class InvitationTarget; +class InvitationParams; +class SendInvitationRequest; +class SendInvitationResponse; +class UpdateInvitationRequest; +class GenericInvitationRequest; + +// =================================================================== + +class TC_SHARED_API Invitation : public ::google::protobuf::Message { + public: + Invitation(); + virtual ~Invitation(); + + Invitation(const Invitation& from); + + inline Invitation& operator=(const Invitation& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Invitation& default_instance(); + + void Swap(Invitation* other); + + // implements Message ---------------------------------------------- + + Invitation* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Invitation& from); + void MergeFrom(const Invitation& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed64 id = 1; + inline bool has_id() const; + inline void clear_id(); + static const int kIdFieldNumber = 1; + inline ::google::protobuf::uint64 id() const; + inline void set_id(::google::protobuf::uint64 value); + + // required .bgs.protocol.Identity inviter_identity = 2; + inline bool has_inviter_identity() const; + inline void clear_inviter_identity(); + static const int kInviterIdentityFieldNumber = 2; + inline const ::bgs::protocol::Identity& inviter_identity() const; + inline ::bgs::protocol::Identity* mutable_inviter_identity(); + inline ::bgs::protocol::Identity* release_inviter_identity(); + inline void set_allocated_inviter_identity(::bgs::protocol::Identity* inviter_identity); + + // required .bgs.protocol.Identity invitee_identity = 3; + inline bool has_invitee_identity() const; + inline void clear_invitee_identity(); + static const int kInviteeIdentityFieldNumber = 3; + inline const ::bgs::protocol::Identity& invitee_identity() const; + inline ::bgs::protocol::Identity* mutable_invitee_identity(); + inline ::bgs::protocol::Identity* release_invitee_identity(); + inline void set_allocated_invitee_identity(::bgs::protocol::Identity* invitee_identity); + + // optional string inviter_name = 4; + inline bool has_inviter_name() const; + inline void clear_inviter_name(); + static const int kInviterNameFieldNumber = 4; + inline const ::std::string& inviter_name() const; + inline void set_inviter_name(const ::std::string& value); + inline void set_inviter_name(const char* value); + inline void set_inviter_name(const char* value, size_t size); + inline ::std::string* mutable_inviter_name(); + inline ::std::string* release_inviter_name(); + inline void set_allocated_inviter_name(::std::string* inviter_name); + + // optional string invitee_name = 5; + inline bool has_invitee_name() const; + inline void clear_invitee_name(); + static const int kInviteeNameFieldNumber = 5; + inline const ::std::string& invitee_name() const; + inline void set_invitee_name(const ::std::string& value); + inline void set_invitee_name(const char* value); + inline void set_invitee_name(const char* value, size_t size); + inline ::std::string* mutable_invitee_name(); + inline ::std::string* release_invitee_name(); + inline void set_allocated_invitee_name(::std::string* invitee_name); + + // optional string invitation_message = 6; + inline bool has_invitation_message() const; + inline void clear_invitation_message(); + static const int kInvitationMessageFieldNumber = 6; + inline const ::std::string& invitation_message() const; + inline void set_invitation_message(const ::std::string& value); + inline void set_invitation_message(const char* value); + inline void set_invitation_message(const char* value, size_t size); + inline ::std::string* mutable_invitation_message(); + inline ::std::string* release_invitation_message(); + inline void set_allocated_invitation_message(::std::string* invitation_message); + + // optional uint64 creation_time = 7; + inline bool has_creation_time() const; + inline void clear_creation_time(); + static const int kCreationTimeFieldNumber = 7; + inline ::google::protobuf::uint64 creation_time() const; + inline void set_creation_time(::google::protobuf::uint64 value); + + // optional uint64 expiration_time = 8; + inline bool has_expiration_time() const; + inline void clear_expiration_time(); + static const int kExpirationTimeFieldNumber = 8; + inline ::google::protobuf::uint64 expiration_time() const; + inline void set_expiration_time(::google::protobuf::uint64 value); + + GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(Invitation) + // @@protoc_insertion_point(class_scope:bgs.protocol.Invitation) + private: + inline void set_has_id(); + inline void clear_has_id(); + inline void set_has_inviter_identity(); + inline void clear_has_inviter_identity(); + inline void set_has_invitee_identity(); + inline void clear_has_invitee_identity(); + inline void set_has_inviter_name(); + inline void clear_has_inviter_name(); + inline void set_has_invitee_name(); + inline void clear_has_invitee_name(); + inline void set_has_invitation_message(); + inline void clear_has_invitation_message(); + inline void set_has_creation_time(); + inline void clear_has_creation_time(); + inline void set_has_expiration_time(); + inline void clear_has_expiration_time(); + + ::google::protobuf::internal::ExtensionSet _extensions_; + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint64 id_; + ::bgs::protocol::Identity* inviter_identity_; + ::bgs::protocol::Identity* invitee_identity_; + ::std::string* inviter_name_; + ::std::string* invitee_name_; + ::std::string* invitation_message_; + ::google::protobuf::uint64 creation_time_; + ::google::protobuf::uint64 expiration_time_; + friend void TC_SHARED_API protobuf_AddDesc_invitation_5ftypes_2eproto(); + friend void protobuf_AssignDesc_invitation_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_invitation_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static Invitation* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API InvitationSuggestion : public ::google::protobuf::Message { + public: + InvitationSuggestion(); + virtual ~InvitationSuggestion(); + + InvitationSuggestion(const InvitationSuggestion& from); + + inline InvitationSuggestion& operator=(const InvitationSuggestion& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const InvitationSuggestion& default_instance(); + + void Swap(InvitationSuggestion* other); + + // implements Message ---------------------------------------------- + + InvitationSuggestion* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const InvitationSuggestion& from); + void MergeFrom(const InvitationSuggestion& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId channel_id = 1; + inline bool has_channel_id() const; + inline void clear_channel_id(); + static const int kChannelIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& channel_id() const; + inline ::bgs::protocol::EntityId* mutable_channel_id(); + inline ::bgs::protocol::EntityId* release_channel_id(); + inline void set_allocated_channel_id(::bgs::protocol::EntityId* channel_id); + + // required .bgs.protocol.EntityId suggester_id = 2; + inline bool has_suggester_id() const; + inline void clear_suggester_id(); + static const int kSuggesterIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& suggester_id() const; + inline ::bgs::protocol::EntityId* mutable_suggester_id(); + inline ::bgs::protocol::EntityId* release_suggester_id(); + inline void set_allocated_suggester_id(::bgs::protocol::EntityId* suggester_id); + + // required .bgs.protocol.EntityId suggestee_id = 3; + inline bool has_suggestee_id() const; + inline void clear_suggestee_id(); + static const int kSuggesteeIdFieldNumber = 3; + inline const ::bgs::protocol::EntityId& suggestee_id() const; + inline ::bgs::protocol::EntityId* mutable_suggestee_id(); + inline ::bgs::protocol::EntityId* release_suggestee_id(); + inline void set_allocated_suggestee_id(::bgs::protocol::EntityId* suggestee_id); + + // optional string suggester_name = 4; + inline bool has_suggester_name() const; + inline void clear_suggester_name(); + static const int kSuggesterNameFieldNumber = 4; + inline const ::std::string& suggester_name() const; + inline void set_suggester_name(const ::std::string& value); + inline void set_suggester_name(const char* value); + inline void set_suggester_name(const char* value, size_t size); + inline ::std::string* mutable_suggester_name(); + inline ::std::string* release_suggester_name(); + inline void set_allocated_suggester_name(::std::string* suggester_name); + + // optional string suggestee_name = 5; + inline bool has_suggestee_name() const; + inline void clear_suggestee_name(); + static const int kSuggesteeNameFieldNumber = 5; + inline const ::std::string& suggestee_name() const; + inline void set_suggestee_name(const ::std::string& value); + inline void set_suggestee_name(const char* value); + inline void set_suggestee_name(const char* value, size_t size); + inline ::std::string* mutable_suggestee_name(); + inline ::std::string* release_suggestee_name(); + inline void set_allocated_suggestee_name(::std::string* suggestee_name); + + // optional .bgs.protocol.EntityId suggester_account_id = 6; + inline bool has_suggester_account_id() const; + inline void clear_suggester_account_id(); + static const int kSuggesterAccountIdFieldNumber = 6; + inline const ::bgs::protocol::EntityId& suggester_account_id() const; + inline ::bgs::protocol::EntityId* mutable_suggester_account_id(); + inline ::bgs::protocol::EntityId* release_suggester_account_id(); + inline void set_allocated_suggester_account_id(::bgs::protocol::EntityId* suggester_account_id); + + // @@protoc_insertion_point(class_scope:bgs.protocol.InvitationSuggestion) + private: + inline void set_has_channel_id(); + inline void clear_has_channel_id(); + inline void set_has_suggester_id(); + inline void clear_has_suggester_id(); + inline void set_has_suggestee_id(); + inline void clear_has_suggestee_id(); + inline void set_has_suggester_name(); + inline void clear_has_suggester_name(); + inline void set_has_suggestee_name(); + inline void clear_has_suggestee_name(); + inline void set_has_suggester_account_id(); + inline void clear_has_suggester_account_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* channel_id_; + ::bgs::protocol::EntityId* suggester_id_; + ::bgs::protocol::EntityId* suggestee_id_; + ::std::string* suggester_name_; + ::std::string* suggestee_name_; + ::bgs::protocol::EntityId* suggester_account_id_; + friend void TC_SHARED_API protobuf_AddDesc_invitation_5ftypes_2eproto(); + friend void protobuf_AssignDesc_invitation_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_invitation_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static InvitationSuggestion* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API InvitationTarget : public ::google::protobuf::Message { + public: + InvitationTarget(); + virtual ~InvitationTarget(); + + InvitationTarget(const InvitationTarget& from); + + inline InvitationTarget& operator=(const InvitationTarget& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const InvitationTarget& default_instance(); + + void Swap(InvitationTarget* other); + + // implements Message ---------------------------------------------- + + InvitationTarget* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const InvitationTarget& from); + void MergeFrom(const InvitationTarget& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.Identity identity = 1; + inline bool has_identity() const; + inline void clear_identity(); + static const int kIdentityFieldNumber = 1; + inline const ::bgs::protocol::Identity& identity() const; + inline ::bgs::protocol::Identity* mutable_identity(); + inline ::bgs::protocol::Identity* release_identity(); + inline void set_allocated_identity(::bgs::protocol::Identity* identity); + + // optional string email = 2; + inline bool has_email() const; + inline void clear_email(); + static const int kEmailFieldNumber = 2; + inline const ::std::string& email() const; + inline void set_email(const ::std::string& value); + inline void set_email(const char* value); + inline void set_email(const char* value, size_t size); + inline ::std::string* mutable_email(); + inline ::std::string* release_email(); + inline void set_allocated_email(::std::string* email); + + // optional string battle_tag = 3; + inline bool has_battle_tag() const; + inline void clear_battle_tag(); + static const int kBattleTagFieldNumber = 3; + inline const ::std::string& battle_tag() const; + inline void set_battle_tag(const ::std::string& value); + inline void set_battle_tag(const char* value); + inline void set_battle_tag(const char* value, size_t size); + inline ::std::string* mutable_battle_tag(); + inline ::std::string* release_battle_tag(); + inline void set_allocated_battle_tag(::std::string* battle_tag); + + GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(InvitationTarget) + // @@protoc_insertion_point(class_scope:bgs.protocol.InvitationTarget) + private: + inline void set_has_identity(); + inline void clear_has_identity(); + inline void set_has_email(); + inline void clear_has_email(); + inline void set_has_battle_tag(); + inline void clear_has_battle_tag(); + + ::google::protobuf::internal::ExtensionSet _extensions_; + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::Identity* identity_; + ::std::string* email_; + ::std::string* battle_tag_; + friend void TC_SHARED_API protobuf_AddDesc_invitation_5ftypes_2eproto(); + friend void protobuf_AssignDesc_invitation_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_invitation_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static InvitationTarget* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API InvitationParams : public ::google::protobuf::Message { + public: + InvitationParams(); + virtual ~InvitationParams(); + + InvitationParams(const InvitationParams& from); + + inline InvitationParams& operator=(const InvitationParams& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const InvitationParams& default_instance(); + + void Swap(InvitationParams* other); + + // implements Message ---------------------------------------------- + + InvitationParams* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const InvitationParams& from); + void MergeFrom(const InvitationParams& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string invitation_message = 1; + inline bool has_invitation_message() const; + inline void clear_invitation_message(); + static const int kInvitationMessageFieldNumber = 1; + inline const ::std::string& invitation_message() const; + inline void set_invitation_message(const ::std::string& value); + inline void set_invitation_message(const char* value); + inline void set_invitation_message(const char* value, size_t size); + inline ::std::string* mutable_invitation_message(); + inline ::std::string* release_invitation_message(); + inline void set_allocated_invitation_message(::std::string* invitation_message); + + // optional uint64 expiration_time = 2 [default = 0]; + inline bool has_expiration_time() const; + inline void clear_expiration_time(); + static const int kExpirationTimeFieldNumber = 2; + inline ::google::protobuf::uint64 expiration_time() const; + inline void set_expiration_time(::google::protobuf::uint64 value); + + GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(InvitationParams) + // @@protoc_insertion_point(class_scope:bgs.protocol.InvitationParams) + private: + inline void set_has_invitation_message(); + inline void clear_has_invitation_message(); + inline void set_has_expiration_time(); + inline void clear_has_expiration_time(); + + ::google::protobuf::internal::ExtensionSet _extensions_; + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* invitation_message_; + ::google::protobuf::uint64 expiration_time_; + friend void TC_SHARED_API protobuf_AddDesc_invitation_5ftypes_2eproto(); + friend void protobuf_AssignDesc_invitation_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_invitation_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static InvitationParams* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API SendInvitationRequest : public ::google::protobuf::Message { + public: + SendInvitationRequest(); + virtual ~SendInvitationRequest(); + + SendInvitationRequest(const SendInvitationRequest& from); + + inline SendInvitationRequest& operator=(const SendInvitationRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SendInvitationRequest& default_instance(); + + void Swap(SendInvitationRequest* other); + + // implements Message ---------------------------------------------- + + SendInvitationRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SendInvitationRequest& from); + void MergeFrom(const SendInvitationRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.Identity agent_identity = 1; + inline bool has_agent_identity() const; + inline void clear_agent_identity(); + static const int kAgentIdentityFieldNumber = 1; + inline const ::bgs::protocol::Identity& agent_identity() const; + inline ::bgs::protocol::Identity* mutable_agent_identity(); + inline ::bgs::protocol::Identity* release_agent_identity(); + inline void set_allocated_agent_identity(::bgs::protocol::Identity* agent_identity); + + // required .bgs.protocol.EntityId target_id = 2 [deprecated = true]; + inline bool has_target_id() const PROTOBUF_DEPRECATED; + inline void clear_target_id() PROTOBUF_DEPRECATED; + static const int kTargetIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& target_id() const PROTOBUF_DEPRECATED; + inline ::bgs::protocol::EntityId* mutable_target_id() PROTOBUF_DEPRECATED; + inline ::bgs::protocol::EntityId* release_target_id() PROTOBUF_DEPRECATED; + inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id) PROTOBUF_DEPRECATED; + + // required .bgs.protocol.InvitationParams params = 3; + inline bool has_params() const; + inline void clear_params(); + static const int kParamsFieldNumber = 3; + inline const ::bgs::protocol::InvitationParams& params() const; + inline ::bgs::protocol::InvitationParams* mutable_params(); + inline ::bgs::protocol::InvitationParams* release_params(); + inline void set_allocated_params(::bgs::protocol::InvitationParams* params); + + // optional .bgs.protocol.AccountInfo agent_info = 4; + inline bool has_agent_info() const; + inline void clear_agent_info(); + static const int kAgentInfoFieldNumber = 4; + inline const ::bgs::protocol::AccountInfo& agent_info() const; + inline ::bgs::protocol::AccountInfo* mutable_agent_info(); + inline ::bgs::protocol::AccountInfo* release_agent_info(); + inline void set_allocated_agent_info(::bgs::protocol::AccountInfo* agent_info); + + // optional .bgs.protocol.InvitationTarget target = 5; + inline bool has_target() const; + inline void clear_target(); + static const int kTargetFieldNumber = 5; + inline const ::bgs::protocol::InvitationTarget& target() const; + inline ::bgs::protocol::InvitationTarget* mutable_target(); + inline ::bgs::protocol::InvitationTarget* release_target(); + inline void set_allocated_target(::bgs::protocol::InvitationTarget* target); + + // @@protoc_insertion_point(class_scope:bgs.protocol.SendInvitationRequest) + private: + inline void set_has_agent_identity(); + inline void clear_has_agent_identity(); + inline void set_has_target_id(); + inline void clear_has_target_id(); + inline void set_has_params(); + inline void clear_has_params(); + inline void set_has_agent_info(); + inline void clear_has_agent_info(); + inline void set_has_target(); + inline void clear_has_target(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::Identity* agent_identity_; + ::bgs::protocol::EntityId* target_id_; + ::bgs::protocol::InvitationParams* params_; + ::bgs::protocol::AccountInfo* agent_info_; + ::bgs::protocol::InvitationTarget* target_; + friend void TC_SHARED_API protobuf_AddDesc_invitation_5ftypes_2eproto(); + friend void protobuf_AssignDesc_invitation_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_invitation_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static SendInvitationRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API SendInvitationResponse : public ::google::protobuf::Message { + public: + SendInvitationResponse(); + virtual ~SendInvitationResponse(); + + SendInvitationResponse(const SendInvitationResponse& from); + + inline SendInvitationResponse& operator=(const SendInvitationResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SendInvitationResponse& default_instance(); + + void Swap(SendInvitationResponse* other); + + // implements Message ---------------------------------------------- + + SendInvitationResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SendInvitationResponse& from); + void MergeFrom(const SendInvitationResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.Invitation invitation = 2; + inline bool has_invitation() const; + inline void clear_invitation(); + static const int kInvitationFieldNumber = 2; + inline const ::bgs::protocol::Invitation& invitation() const; + inline ::bgs::protocol::Invitation* mutable_invitation(); + inline ::bgs::protocol::Invitation* release_invitation(); + inline void set_allocated_invitation(::bgs::protocol::Invitation* invitation); + + // @@protoc_insertion_point(class_scope:bgs.protocol.SendInvitationResponse) + private: + inline void set_has_invitation(); + inline void clear_has_invitation(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::Invitation* invitation_; + friend void TC_SHARED_API protobuf_AddDesc_invitation_5ftypes_2eproto(); + friend void protobuf_AssignDesc_invitation_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_invitation_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static SendInvitationResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API UpdateInvitationRequest : public ::google::protobuf::Message { + public: + UpdateInvitationRequest(); + virtual ~UpdateInvitationRequest(); + + UpdateInvitationRequest(const UpdateInvitationRequest& from); + + inline UpdateInvitationRequest& operator=(const UpdateInvitationRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const UpdateInvitationRequest& default_instance(); + + void Swap(UpdateInvitationRequest* other); + + // implements Message ---------------------------------------------- + + UpdateInvitationRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const UpdateInvitationRequest& from); + void MergeFrom(const UpdateInvitationRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.Identity agent_identity = 1; + inline bool has_agent_identity() const; + inline void clear_agent_identity(); + static const int kAgentIdentityFieldNumber = 1; + inline const ::bgs::protocol::Identity& agent_identity() const; + inline ::bgs::protocol::Identity* mutable_agent_identity(); + inline ::bgs::protocol::Identity* release_agent_identity(); + inline void set_allocated_agent_identity(::bgs::protocol::Identity* agent_identity); + + // required fixed64 invitation_id = 2; + inline bool has_invitation_id() const; + inline void clear_invitation_id(); + static const int kInvitationIdFieldNumber = 2; + inline ::google::protobuf::uint64 invitation_id() const; + inline void set_invitation_id(::google::protobuf::uint64 value); + + // required .bgs.protocol.InvitationParams params = 3; + inline bool has_params() const; + inline void clear_params(); + static const int kParamsFieldNumber = 3; + inline const ::bgs::protocol::InvitationParams& params() const; + inline ::bgs::protocol::InvitationParams* mutable_params(); + inline ::bgs::protocol::InvitationParams* release_params(); + inline void set_allocated_params(::bgs::protocol::InvitationParams* params); + + // @@protoc_insertion_point(class_scope:bgs.protocol.UpdateInvitationRequest) + private: + inline void set_has_agent_identity(); + inline void clear_has_agent_identity(); + inline void set_has_invitation_id(); + inline void clear_has_invitation_id(); + inline void set_has_params(); + inline void clear_has_params(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::Identity* agent_identity_; + ::google::protobuf::uint64 invitation_id_; + ::bgs::protocol::InvitationParams* params_; + friend void TC_SHARED_API protobuf_AddDesc_invitation_5ftypes_2eproto(); + friend void protobuf_AssignDesc_invitation_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_invitation_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static UpdateInvitationRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API GenericInvitationRequest : public ::google::protobuf::Message { + public: + GenericInvitationRequest(); + virtual ~GenericInvitationRequest(); + + GenericInvitationRequest(const GenericInvitationRequest& from); + + inline GenericInvitationRequest& operator=(const GenericInvitationRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const GenericInvitationRequest& default_instance(); + + void Swap(GenericInvitationRequest* other); + + // implements Message ---------------------------------------------- + + GenericInvitationRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GenericInvitationRequest& from); + void MergeFrom(const GenericInvitationRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // optional .bgs.protocol.EntityId target_id = 2; + inline bool has_target_id() const; + inline void clear_target_id(); + static const int kTargetIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& target_id() const; + inline ::bgs::protocol::EntityId* mutable_target_id(); + inline ::bgs::protocol::EntityId* release_target_id(); + inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id); + + // required fixed64 invitation_id = 3; + inline bool has_invitation_id() const; + inline void clear_invitation_id(); + static const int kInvitationIdFieldNumber = 3; + inline ::google::protobuf::uint64 invitation_id() const; + inline void set_invitation_id(::google::protobuf::uint64 value); + + // optional string invitee_name = 4; + inline bool has_invitee_name() const; + inline void clear_invitee_name(); + static const int kInviteeNameFieldNumber = 4; + inline const ::std::string& invitee_name() const; + inline void set_invitee_name(const ::std::string& value); + inline void set_invitee_name(const char* value); + inline void set_invitee_name(const char* value, size_t size); + inline ::std::string* mutable_invitee_name(); + inline ::std::string* release_invitee_name(); + inline void set_allocated_invitee_name(::std::string* invitee_name); + + // optional string inviter_name = 5; + inline bool has_inviter_name() const; + inline void clear_inviter_name(); + static const int kInviterNameFieldNumber = 5; + inline const ::std::string& inviter_name() const; + inline void set_inviter_name(const ::std::string& value); + inline void set_inviter_name(const char* value); + inline void set_inviter_name(const char* value, size_t size); + inline ::std::string* mutable_inviter_name(); + inline ::std::string* release_inviter_name(); + inline void set_allocated_inviter_name(::std::string* inviter_name); + + // repeated uint32 previous_role = 6 [packed = true]; + inline int previous_role_size() const; + inline void clear_previous_role(); + static const int kPreviousRoleFieldNumber = 6; + inline ::google::protobuf::uint32 previous_role(int index) const; + inline void set_previous_role(int index, ::google::protobuf::uint32 value); + inline void add_previous_role(::google::protobuf::uint32 value); + inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + previous_role() const; + inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_previous_role(); + + // repeated uint32 desired_role = 7 [packed = true]; + inline int desired_role_size() const; + inline void clear_desired_role(); + static const int kDesiredRoleFieldNumber = 7; + inline ::google::protobuf::uint32 desired_role(int index) const; + inline void set_desired_role(int index, ::google::protobuf::uint32 value); + inline void add_desired_role(::google::protobuf::uint32 value); + inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + desired_role() const; + inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_desired_role(); + + // optional uint32 reason = 8; + inline bool has_reason() const; + inline void clear_reason(); + static const int kReasonFieldNumber = 8; + inline ::google::protobuf::uint32 reason() const; + inline void set_reason(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.GenericInvitationRequest) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_target_id(); + inline void clear_has_target_id(); + inline void set_has_invitation_id(); + inline void clear_has_invitation_id(); + inline void set_has_invitee_name(); + inline void clear_has_invitee_name(); + inline void set_has_inviter_name(); + inline void clear_has_inviter_name(); + inline void set_has_reason(); + inline void clear_has_reason(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::bgs::protocol::EntityId* target_id_; + ::google::protobuf::uint64 invitation_id_; + ::std::string* invitee_name_; + ::std::string* inviter_name_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > previous_role_; + mutable int _previous_role_cached_byte_size_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > desired_role_; + mutable int _desired_role_cached_byte_size_; + ::google::protobuf::uint32 reason_; + friend void TC_SHARED_API protobuf_AddDesc_invitation_5ftypes_2eproto(); + friend void protobuf_AssignDesc_invitation_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_invitation_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static GenericInvitationRequest* default_instance_; +}; +// =================================================================== + + +// =================================================================== + + +// =================================================================== + +// Invitation + +// required fixed64 id = 1; +inline bool Invitation::has_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Invitation::set_has_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void Invitation::clear_has_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Invitation::clear_id() { + id_ = GOOGLE_ULONGLONG(0); + clear_has_id(); +} +inline ::google::protobuf::uint64 Invitation::id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Invitation.id) + return id_; +} +inline void Invitation::set_id(::google::protobuf::uint64 value) { + set_has_id(); + id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.Invitation.id) +} + +// required .bgs.protocol.Identity inviter_identity = 2; +inline bool Invitation::has_inviter_identity() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Invitation::set_has_inviter_identity() { + _has_bits_[0] |= 0x00000002u; +} +inline void Invitation::clear_has_inviter_identity() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Invitation::clear_inviter_identity() { + if (inviter_identity_ != NULL) inviter_identity_->::bgs::protocol::Identity::Clear(); + clear_has_inviter_identity(); +} +inline const ::bgs::protocol::Identity& Invitation::inviter_identity() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Invitation.inviter_identity) + return inviter_identity_ != NULL ? *inviter_identity_ : *default_instance_->inviter_identity_; +} +inline ::bgs::protocol::Identity* Invitation::mutable_inviter_identity() { + set_has_inviter_identity(); + if (inviter_identity_ == NULL) inviter_identity_ = new ::bgs::protocol::Identity; + // @@protoc_insertion_point(field_mutable:bgs.protocol.Invitation.inviter_identity) + return inviter_identity_; +} +inline ::bgs::protocol::Identity* Invitation::release_inviter_identity() { + clear_has_inviter_identity(); + ::bgs::protocol::Identity* temp = inviter_identity_; + inviter_identity_ = NULL; + return temp; +} +inline void Invitation::set_allocated_inviter_identity(::bgs::protocol::Identity* inviter_identity) { + delete inviter_identity_; + inviter_identity_ = inviter_identity; + if (inviter_identity) { + set_has_inviter_identity(); + } else { + clear_has_inviter_identity(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Invitation.inviter_identity) +} + +// required .bgs.protocol.Identity invitee_identity = 3; +inline bool Invitation::has_invitee_identity() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void Invitation::set_has_invitee_identity() { + _has_bits_[0] |= 0x00000004u; +} +inline void Invitation::clear_has_invitee_identity() { + _has_bits_[0] &= ~0x00000004u; +} +inline void Invitation::clear_invitee_identity() { + if (invitee_identity_ != NULL) invitee_identity_->::bgs::protocol::Identity::Clear(); + clear_has_invitee_identity(); +} +inline const ::bgs::protocol::Identity& Invitation::invitee_identity() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Invitation.invitee_identity) + return invitee_identity_ != NULL ? *invitee_identity_ : *default_instance_->invitee_identity_; +} +inline ::bgs::protocol::Identity* Invitation::mutable_invitee_identity() { + set_has_invitee_identity(); + if (invitee_identity_ == NULL) invitee_identity_ = new ::bgs::protocol::Identity; + // @@protoc_insertion_point(field_mutable:bgs.protocol.Invitation.invitee_identity) + return invitee_identity_; +} +inline ::bgs::protocol::Identity* Invitation::release_invitee_identity() { + clear_has_invitee_identity(); + ::bgs::protocol::Identity* temp = invitee_identity_; + invitee_identity_ = NULL; + return temp; +} +inline void Invitation::set_allocated_invitee_identity(::bgs::protocol::Identity* invitee_identity) { + delete invitee_identity_; + invitee_identity_ = invitee_identity; + if (invitee_identity) { + set_has_invitee_identity(); + } else { + clear_has_invitee_identity(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Invitation.invitee_identity) +} + +// optional string inviter_name = 4; +inline bool Invitation::has_inviter_name() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void Invitation::set_has_inviter_name() { + _has_bits_[0] |= 0x00000008u; +} +inline void Invitation::clear_has_inviter_name() { + _has_bits_[0] &= ~0x00000008u; +} +inline void Invitation::clear_inviter_name() { + if (inviter_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + inviter_name_->clear(); + } + clear_has_inviter_name(); +} +inline const ::std::string& Invitation::inviter_name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Invitation.inviter_name) + return *inviter_name_; +} +inline void Invitation::set_inviter_name(const ::std::string& value) { + set_has_inviter_name(); + if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + inviter_name_ = new ::std::string; + } + inviter_name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.Invitation.inviter_name) +} +inline void Invitation::set_inviter_name(const char* value) { + set_has_inviter_name(); + if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + inviter_name_ = new ::std::string; + } + inviter_name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.Invitation.inviter_name) +} +inline void Invitation::set_inviter_name(const char* value, size_t size) { + set_has_inviter_name(); + if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + inviter_name_ = new ::std::string; + } + inviter_name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.Invitation.inviter_name) +} +inline ::std::string* Invitation::mutable_inviter_name() { + set_has_inviter_name(); + if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + inviter_name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.Invitation.inviter_name) + return inviter_name_; +} +inline ::std::string* Invitation::release_inviter_name() { + clear_has_inviter_name(); + if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = inviter_name_; + inviter_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void Invitation::set_allocated_inviter_name(::std::string* inviter_name) { + if (inviter_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete inviter_name_; + } + if (inviter_name) { + set_has_inviter_name(); + inviter_name_ = inviter_name; + } else { + clear_has_inviter_name(); + inviter_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Invitation.inviter_name) +} + +// optional string invitee_name = 5; +inline bool Invitation::has_invitee_name() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void Invitation::set_has_invitee_name() { + _has_bits_[0] |= 0x00000010u; +} +inline void Invitation::clear_has_invitee_name() { + _has_bits_[0] &= ~0x00000010u; +} +inline void Invitation::clear_invitee_name() { + if (invitee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitee_name_->clear(); + } + clear_has_invitee_name(); +} +inline const ::std::string& Invitation::invitee_name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Invitation.invitee_name) + return *invitee_name_; +} +inline void Invitation::set_invitee_name(const ::std::string& value) { + set_has_invitee_name(); + if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitee_name_ = new ::std::string; + } + invitee_name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.Invitation.invitee_name) +} +inline void Invitation::set_invitee_name(const char* value) { + set_has_invitee_name(); + if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitee_name_ = new ::std::string; + } + invitee_name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.Invitation.invitee_name) +} +inline void Invitation::set_invitee_name(const char* value, size_t size) { + set_has_invitee_name(); + if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitee_name_ = new ::std::string; + } + invitee_name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.Invitation.invitee_name) +} +inline ::std::string* Invitation::mutable_invitee_name() { + set_has_invitee_name(); + if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitee_name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.Invitation.invitee_name) + return invitee_name_; +} +inline ::std::string* Invitation::release_invitee_name() { + clear_has_invitee_name(); + if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = invitee_name_; + invitee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void Invitation::set_allocated_invitee_name(::std::string* invitee_name) { + if (invitee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete invitee_name_; + } + if (invitee_name) { + set_has_invitee_name(); + invitee_name_ = invitee_name; + } else { + clear_has_invitee_name(); + invitee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Invitation.invitee_name) +} + +// optional string invitation_message = 6; +inline bool Invitation::has_invitation_message() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void Invitation::set_has_invitation_message() { + _has_bits_[0] |= 0x00000020u; +} +inline void Invitation::clear_has_invitation_message() { + _has_bits_[0] &= ~0x00000020u; +} +inline void Invitation::clear_invitation_message() { + if (invitation_message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitation_message_->clear(); + } + clear_has_invitation_message(); +} +inline const ::std::string& Invitation::invitation_message() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Invitation.invitation_message) + return *invitation_message_; +} +inline void Invitation::set_invitation_message(const ::std::string& value) { + set_has_invitation_message(); + if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitation_message_ = new ::std::string; + } + invitation_message_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.Invitation.invitation_message) +} +inline void Invitation::set_invitation_message(const char* value) { + set_has_invitation_message(); + if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitation_message_ = new ::std::string; + } + invitation_message_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.Invitation.invitation_message) +} +inline void Invitation::set_invitation_message(const char* value, size_t size) { + set_has_invitation_message(); + if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitation_message_ = new ::std::string; + } + invitation_message_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.Invitation.invitation_message) +} +inline ::std::string* Invitation::mutable_invitation_message() { + set_has_invitation_message(); + if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitation_message_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.Invitation.invitation_message) + return invitation_message_; +} +inline ::std::string* Invitation::release_invitation_message() { + clear_has_invitation_message(); + if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = invitation_message_; + invitation_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void Invitation::set_allocated_invitation_message(::std::string* invitation_message) { + if (invitation_message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete invitation_message_; + } + if (invitation_message) { + set_has_invitation_message(); + invitation_message_ = invitation_message; + } else { + clear_has_invitation_message(); + invitation_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Invitation.invitation_message) +} + +// optional uint64 creation_time = 7; +inline bool Invitation::has_creation_time() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void Invitation::set_has_creation_time() { + _has_bits_[0] |= 0x00000040u; +} +inline void Invitation::clear_has_creation_time() { + _has_bits_[0] &= ~0x00000040u; +} +inline void Invitation::clear_creation_time() { + creation_time_ = GOOGLE_ULONGLONG(0); + clear_has_creation_time(); +} +inline ::google::protobuf::uint64 Invitation::creation_time() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Invitation.creation_time) + return creation_time_; +} +inline void Invitation::set_creation_time(::google::protobuf::uint64 value) { + set_has_creation_time(); + creation_time_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.Invitation.creation_time) +} + +// optional uint64 expiration_time = 8; +inline bool Invitation::has_expiration_time() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void Invitation::set_has_expiration_time() { + _has_bits_[0] |= 0x00000080u; +} +inline void Invitation::clear_has_expiration_time() { + _has_bits_[0] &= ~0x00000080u; +} +inline void Invitation::clear_expiration_time() { + expiration_time_ = GOOGLE_ULONGLONG(0); + clear_has_expiration_time(); +} +inline ::google::protobuf::uint64 Invitation::expiration_time() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Invitation.expiration_time) + return expiration_time_; +} +inline void Invitation::set_expiration_time(::google::protobuf::uint64 value) { + set_has_expiration_time(); + expiration_time_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.Invitation.expiration_time) +} + +// ------------------------------------------------------------------- + +// InvitationSuggestion + +// optional .bgs.protocol.EntityId channel_id = 1; +inline bool InvitationSuggestion::has_channel_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void InvitationSuggestion::set_has_channel_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void InvitationSuggestion::clear_has_channel_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void InvitationSuggestion::clear_channel_id() { + if (channel_id_ != NULL) channel_id_->::bgs::protocol::EntityId::Clear(); + clear_has_channel_id(); +} +inline const ::bgs::protocol::EntityId& InvitationSuggestion::channel_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.InvitationSuggestion.channel_id) + return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_; +} +inline ::bgs::protocol::EntityId* InvitationSuggestion::mutable_channel_id() { + set_has_channel_id(); + if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationSuggestion.channel_id) + return channel_id_; +} +inline ::bgs::protocol::EntityId* InvitationSuggestion::release_channel_id() { + clear_has_channel_id(); + ::bgs::protocol::EntityId* temp = channel_id_; + channel_id_ = NULL; + return temp; +} +inline void InvitationSuggestion::set_allocated_channel_id(::bgs::protocol::EntityId* channel_id) { + delete channel_id_; + channel_id_ = channel_id; + if (channel_id) { + set_has_channel_id(); + } else { + clear_has_channel_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationSuggestion.channel_id) +} + +// required .bgs.protocol.EntityId suggester_id = 2; +inline bool InvitationSuggestion::has_suggester_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void InvitationSuggestion::set_has_suggester_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void InvitationSuggestion::clear_has_suggester_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void InvitationSuggestion::clear_suggester_id() { + if (suggester_id_ != NULL) suggester_id_->::bgs::protocol::EntityId::Clear(); + clear_has_suggester_id(); +} +inline const ::bgs::protocol::EntityId& InvitationSuggestion::suggester_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.InvitationSuggestion.suggester_id) + return suggester_id_ != NULL ? *suggester_id_ : *default_instance_->suggester_id_; +} +inline ::bgs::protocol::EntityId* InvitationSuggestion::mutable_suggester_id() { + set_has_suggester_id(); + if (suggester_id_ == NULL) suggester_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationSuggestion.suggester_id) + return suggester_id_; +} +inline ::bgs::protocol::EntityId* InvitationSuggestion::release_suggester_id() { + clear_has_suggester_id(); + ::bgs::protocol::EntityId* temp = suggester_id_; + suggester_id_ = NULL; + return temp; +} +inline void InvitationSuggestion::set_allocated_suggester_id(::bgs::protocol::EntityId* suggester_id) { + delete suggester_id_; + suggester_id_ = suggester_id; + if (suggester_id) { + set_has_suggester_id(); + } else { + clear_has_suggester_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationSuggestion.suggester_id) +} + +// required .bgs.protocol.EntityId suggestee_id = 3; +inline bool InvitationSuggestion::has_suggestee_id() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void InvitationSuggestion::set_has_suggestee_id() { + _has_bits_[0] |= 0x00000004u; +} +inline void InvitationSuggestion::clear_has_suggestee_id() { + _has_bits_[0] &= ~0x00000004u; +} +inline void InvitationSuggestion::clear_suggestee_id() { + if (suggestee_id_ != NULL) suggestee_id_->::bgs::protocol::EntityId::Clear(); + clear_has_suggestee_id(); +} +inline const ::bgs::protocol::EntityId& InvitationSuggestion::suggestee_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.InvitationSuggestion.suggestee_id) + return suggestee_id_ != NULL ? *suggestee_id_ : *default_instance_->suggestee_id_; +} +inline ::bgs::protocol::EntityId* InvitationSuggestion::mutable_suggestee_id() { + set_has_suggestee_id(); + if (suggestee_id_ == NULL) suggestee_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationSuggestion.suggestee_id) + return suggestee_id_; +} +inline ::bgs::protocol::EntityId* InvitationSuggestion::release_suggestee_id() { + clear_has_suggestee_id(); + ::bgs::protocol::EntityId* temp = suggestee_id_; + suggestee_id_ = NULL; + return temp; +} +inline void InvitationSuggestion::set_allocated_suggestee_id(::bgs::protocol::EntityId* suggestee_id) { + delete suggestee_id_; + suggestee_id_ = suggestee_id; + if (suggestee_id) { + set_has_suggestee_id(); + } else { + clear_has_suggestee_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationSuggestion.suggestee_id) +} + +// optional string suggester_name = 4; +inline bool InvitationSuggestion::has_suggester_name() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void InvitationSuggestion::set_has_suggester_name() { + _has_bits_[0] |= 0x00000008u; +} +inline void InvitationSuggestion::clear_has_suggester_name() { + _has_bits_[0] &= ~0x00000008u; +} +inline void InvitationSuggestion::clear_suggester_name() { + if (suggester_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + suggester_name_->clear(); + } + clear_has_suggester_name(); +} +inline const ::std::string& InvitationSuggestion::suggester_name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.InvitationSuggestion.suggester_name) + return *suggester_name_; +} +inline void InvitationSuggestion::set_suggester_name(const ::std::string& value) { + set_has_suggester_name(); + if (suggester_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + suggester_name_ = new ::std::string; + } + suggester_name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.InvitationSuggestion.suggester_name) +} +inline void InvitationSuggestion::set_suggester_name(const char* value) { + set_has_suggester_name(); + if (suggester_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + suggester_name_ = new ::std::string; + } + suggester_name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.InvitationSuggestion.suggester_name) +} +inline void InvitationSuggestion::set_suggester_name(const char* value, size_t size) { + set_has_suggester_name(); + if (suggester_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + suggester_name_ = new ::std::string; + } + suggester_name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.InvitationSuggestion.suggester_name) +} +inline ::std::string* InvitationSuggestion::mutable_suggester_name() { + set_has_suggester_name(); + if (suggester_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + suggester_name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationSuggestion.suggester_name) + return suggester_name_; +} +inline ::std::string* InvitationSuggestion::release_suggester_name() { + clear_has_suggester_name(); + if (suggester_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = suggester_name_; + suggester_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void InvitationSuggestion::set_allocated_suggester_name(::std::string* suggester_name) { + if (suggester_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete suggester_name_; + } + if (suggester_name) { + set_has_suggester_name(); + suggester_name_ = suggester_name; + } else { + clear_has_suggester_name(); + suggester_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationSuggestion.suggester_name) +} + +// optional string suggestee_name = 5; +inline bool InvitationSuggestion::has_suggestee_name() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void InvitationSuggestion::set_has_suggestee_name() { + _has_bits_[0] |= 0x00000010u; +} +inline void InvitationSuggestion::clear_has_suggestee_name() { + _has_bits_[0] &= ~0x00000010u; +} +inline void InvitationSuggestion::clear_suggestee_name() { + if (suggestee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + suggestee_name_->clear(); + } + clear_has_suggestee_name(); +} +inline const ::std::string& InvitationSuggestion::suggestee_name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.InvitationSuggestion.suggestee_name) + return *suggestee_name_; +} +inline void InvitationSuggestion::set_suggestee_name(const ::std::string& value) { + set_has_suggestee_name(); + if (suggestee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + suggestee_name_ = new ::std::string; + } + suggestee_name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.InvitationSuggestion.suggestee_name) +} +inline void InvitationSuggestion::set_suggestee_name(const char* value) { + set_has_suggestee_name(); + if (suggestee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + suggestee_name_ = new ::std::string; + } + suggestee_name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.InvitationSuggestion.suggestee_name) +} +inline void InvitationSuggestion::set_suggestee_name(const char* value, size_t size) { + set_has_suggestee_name(); + if (suggestee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + suggestee_name_ = new ::std::string; + } + suggestee_name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.InvitationSuggestion.suggestee_name) +} +inline ::std::string* InvitationSuggestion::mutable_suggestee_name() { + set_has_suggestee_name(); + if (suggestee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + suggestee_name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationSuggestion.suggestee_name) + return suggestee_name_; +} +inline ::std::string* InvitationSuggestion::release_suggestee_name() { + clear_has_suggestee_name(); + if (suggestee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = suggestee_name_; + suggestee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void InvitationSuggestion::set_allocated_suggestee_name(::std::string* suggestee_name) { + if (suggestee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete suggestee_name_; + } + if (suggestee_name) { + set_has_suggestee_name(); + suggestee_name_ = suggestee_name; + } else { + clear_has_suggestee_name(); + suggestee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationSuggestion.suggestee_name) +} + +// optional .bgs.protocol.EntityId suggester_account_id = 6; +inline bool InvitationSuggestion::has_suggester_account_id() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void InvitationSuggestion::set_has_suggester_account_id() { + _has_bits_[0] |= 0x00000020u; +} +inline void InvitationSuggestion::clear_has_suggester_account_id() { + _has_bits_[0] &= ~0x00000020u; +} +inline void InvitationSuggestion::clear_suggester_account_id() { + if (suggester_account_id_ != NULL) suggester_account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_suggester_account_id(); +} +inline const ::bgs::protocol::EntityId& InvitationSuggestion::suggester_account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.InvitationSuggestion.suggester_account_id) + return suggester_account_id_ != NULL ? *suggester_account_id_ : *default_instance_->suggester_account_id_; +} +inline ::bgs::protocol::EntityId* InvitationSuggestion::mutable_suggester_account_id() { + set_has_suggester_account_id(); + if (suggester_account_id_ == NULL) suggester_account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationSuggestion.suggester_account_id) + return suggester_account_id_; +} +inline ::bgs::protocol::EntityId* InvitationSuggestion::release_suggester_account_id() { + clear_has_suggester_account_id(); + ::bgs::protocol::EntityId* temp = suggester_account_id_; + suggester_account_id_ = NULL; + return temp; +} +inline void InvitationSuggestion::set_allocated_suggester_account_id(::bgs::protocol::EntityId* suggester_account_id) { + delete suggester_account_id_; + suggester_account_id_ = suggester_account_id; + if (suggester_account_id) { + set_has_suggester_account_id(); + } else { + clear_has_suggester_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationSuggestion.suggester_account_id) +} + +// ------------------------------------------------------------------- + +// InvitationTarget + +// optional .bgs.protocol.Identity identity = 1; +inline bool InvitationTarget::has_identity() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void InvitationTarget::set_has_identity() { + _has_bits_[0] |= 0x00000001u; +} +inline void InvitationTarget::clear_has_identity() { + _has_bits_[0] &= ~0x00000001u; +} +inline void InvitationTarget::clear_identity() { + if (identity_ != NULL) identity_->::bgs::protocol::Identity::Clear(); + clear_has_identity(); +} +inline const ::bgs::protocol::Identity& InvitationTarget::identity() const { + // @@protoc_insertion_point(field_get:bgs.protocol.InvitationTarget.identity) + return identity_ != NULL ? *identity_ : *default_instance_->identity_; +} +inline ::bgs::protocol::Identity* InvitationTarget::mutable_identity() { + set_has_identity(); + if (identity_ == NULL) identity_ = new ::bgs::protocol::Identity; + // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationTarget.identity) + return identity_; +} +inline ::bgs::protocol::Identity* InvitationTarget::release_identity() { + clear_has_identity(); + ::bgs::protocol::Identity* temp = identity_; + identity_ = NULL; + return temp; +} +inline void InvitationTarget::set_allocated_identity(::bgs::protocol::Identity* identity) { + delete identity_; + identity_ = identity; + if (identity) { + set_has_identity(); + } else { + clear_has_identity(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationTarget.identity) +} + +// optional string email = 2; +inline bool InvitationTarget::has_email() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void InvitationTarget::set_has_email() { + _has_bits_[0] |= 0x00000002u; +} +inline void InvitationTarget::clear_has_email() { + _has_bits_[0] &= ~0x00000002u; +} +inline void InvitationTarget::clear_email() { + if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_->clear(); + } + clear_has_email(); +} +inline const ::std::string& InvitationTarget::email() const { + // @@protoc_insertion_point(field_get:bgs.protocol.InvitationTarget.email) + return *email_; +} +inline void InvitationTarget::set_email(const ::std::string& value) { + set_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_ = new ::std::string; + } + email_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.InvitationTarget.email) +} +inline void InvitationTarget::set_email(const char* value) { + set_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_ = new ::std::string; + } + email_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.InvitationTarget.email) +} +inline void InvitationTarget::set_email(const char* value, size_t size) { + set_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_ = new ::std::string; + } + email_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.InvitationTarget.email) +} +inline ::std::string* InvitationTarget::mutable_email() { + set_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + email_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationTarget.email) + return email_; +} +inline ::std::string* InvitationTarget::release_email() { + clear_has_email(); + if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = email_; + email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void InvitationTarget::set_allocated_email(::std::string* email) { + if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete email_; + } + if (email) { + set_has_email(); + email_ = email; + } else { + clear_has_email(); + email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationTarget.email) +} + +// optional string battle_tag = 3; +inline bool InvitationTarget::has_battle_tag() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void InvitationTarget::set_has_battle_tag() { + _has_bits_[0] |= 0x00000004u; +} +inline void InvitationTarget::clear_has_battle_tag() { + _has_bits_[0] &= ~0x00000004u; +} +inline void InvitationTarget::clear_battle_tag() { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_->clear(); + } + clear_has_battle_tag(); +} +inline const ::std::string& InvitationTarget::battle_tag() const { + // @@protoc_insertion_point(field_get:bgs.protocol.InvitationTarget.battle_tag) + return *battle_tag_; +} +inline void InvitationTarget::set_battle_tag(const ::std::string& value) { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + battle_tag_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.InvitationTarget.battle_tag) +} +inline void InvitationTarget::set_battle_tag(const char* value) { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + battle_tag_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.InvitationTarget.battle_tag) +} +inline void InvitationTarget::set_battle_tag(const char* value, size_t size) { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + battle_tag_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.InvitationTarget.battle_tag) +} +inline ::std::string* InvitationTarget::mutable_battle_tag() { + set_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + battle_tag_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationTarget.battle_tag) + return battle_tag_; +} +inline ::std::string* InvitationTarget::release_battle_tag() { + clear_has_battle_tag(); + if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = battle_tag_; + battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void InvitationTarget::set_allocated_battle_tag(::std::string* battle_tag) { + if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete battle_tag_; + } + if (battle_tag) { + set_has_battle_tag(); + battle_tag_ = battle_tag; + } else { + clear_has_battle_tag(); + battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationTarget.battle_tag) +} + +// ------------------------------------------------------------------- + +// InvitationParams + +// optional string invitation_message = 1; +inline bool InvitationParams::has_invitation_message() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void InvitationParams::set_has_invitation_message() { + _has_bits_[0] |= 0x00000001u; +} +inline void InvitationParams::clear_has_invitation_message() { + _has_bits_[0] &= ~0x00000001u; +} +inline void InvitationParams::clear_invitation_message() { + if (invitation_message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitation_message_->clear(); + } + clear_has_invitation_message(); +} +inline const ::std::string& InvitationParams::invitation_message() const { + // @@protoc_insertion_point(field_get:bgs.protocol.InvitationParams.invitation_message) + return *invitation_message_; +} +inline void InvitationParams::set_invitation_message(const ::std::string& value) { + set_has_invitation_message(); + if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitation_message_ = new ::std::string; + } + invitation_message_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.InvitationParams.invitation_message) +} +inline void InvitationParams::set_invitation_message(const char* value) { + set_has_invitation_message(); + if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitation_message_ = new ::std::string; + } + invitation_message_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.InvitationParams.invitation_message) +} +inline void InvitationParams::set_invitation_message(const char* value, size_t size) { + set_has_invitation_message(); + if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitation_message_ = new ::std::string; + } + invitation_message_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.InvitationParams.invitation_message) +} +inline ::std::string* InvitationParams::mutable_invitation_message() { + set_has_invitation_message(); + if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitation_message_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationParams.invitation_message) + return invitation_message_; +} +inline ::std::string* InvitationParams::release_invitation_message() { + clear_has_invitation_message(); + if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = invitation_message_; + invitation_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void InvitationParams::set_allocated_invitation_message(::std::string* invitation_message) { + if (invitation_message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete invitation_message_; + } + if (invitation_message) { + set_has_invitation_message(); + invitation_message_ = invitation_message; + } else { + clear_has_invitation_message(); + invitation_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationParams.invitation_message) +} + +// optional uint64 expiration_time = 2 [default = 0]; +inline bool InvitationParams::has_expiration_time() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void InvitationParams::set_has_expiration_time() { + _has_bits_[0] |= 0x00000002u; +} +inline void InvitationParams::clear_has_expiration_time() { + _has_bits_[0] &= ~0x00000002u; +} +inline void InvitationParams::clear_expiration_time() { + expiration_time_ = GOOGLE_ULONGLONG(0); + clear_has_expiration_time(); +} +inline ::google::protobuf::uint64 InvitationParams::expiration_time() const { + // @@protoc_insertion_point(field_get:bgs.protocol.InvitationParams.expiration_time) + return expiration_time_; +} +inline void InvitationParams::set_expiration_time(::google::protobuf::uint64 value) { + set_has_expiration_time(); + expiration_time_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.InvitationParams.expiration_time) +} + +// ------------------------------------------------------------------- + +// SendInvitationRequest + +// optional .bgs.protocol.Identity agent_identity = 1; +inline bool SendInvitationRequest::has_agent_identity() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SendInvitationRequest::set_has_agent_identity() { + _has_bits_[0] |= 0x00000001u; +} +inline void SendInvitationRequest::clear_has_agent_identity() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SendInvitationRequest::clear_agent_identity() { + if (agent_identity_ != NULL) agent_identity_->::bgs::protocol::Identity::Clear(); + clear_has_agent_identity(); +} +inline const ::bgs::protocol::Identity& SendInvitationRequest::agent_identity() const { + // @@protoc_insertion_point(field_get:bgs.protocol.SendInvitationRequest.agent_identity) + return agent_identity_ != NULL ? *agent_identity_ : *default_instance_->agent_identity_; +} +inline ::bgs::protocol::Identity* SendInvitationRequest::mutable_agent_identity() { + set_has_agent_identity(); + if (agent_identity_ == NULL) agent_identity_ = new ::bgs::protocol::Identity; + // @@protoc_insertion_point(field_mutable:bgs.protocol.SendInvitationRequest.agent_identity) + return agent_identity_; +} +inline ::bgs::protocol::Identity* SendInvitationRequest::release_agent_identity() { + clear_has_agent_identity(); + ::bgs::protocol::Identity* temp = agent_identity_; + agent_identity_ = NULL; + return temp; +} +inline void SendInvitationRequest::set_allocated_agent_identity(::bgs::protocol::Identity* agent_identity) { + delete agent_identity_; + agent_identity_ = agent_identity; + if (agent_identity) { + set_has_agent_identity(); + } else { + clear_has_agent_identity(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.SendInvitationRequest.agent_identity) +} + +// required .bgs.protocol.EntityId target_id = 2 [deprecated = true]; +inline bool SendInvitationRequest::has_target_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void SendInvitationRequest::set_has_target_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void SendInvitationRequest::clear_has_target_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void SendInvitationRequest::clear_target_id() { + if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear(); + clear_has_target_id(); +} +inline const ::bgs::protocol::EntityId& SendInvitationRequest::target_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.SendInvitationRequest.target_id) + return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_; +} +inline ::bgs::protocol::EntityId* SendInvitationRequest::mutable_target_id() { + set_has_target_id(); + if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.SendInvitationRequest.target_id) + return target_id_; +} +inline ::bgs::protocol::EntityId* SendInvitationRequest::release_target_id() { + clear_has_target_id(); + ::bgs::protocol::EntityId* temp = target_id_; + target_id_ = NULL; + return temp; +} +inline void SendInvitationRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) { + delete target_id_; + target_id_ = target_id; + if (target_id) { + set_has_target_id(); + } else { + clear_has_target_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.SendInvitationRequest.target_id) +} + +// required .bgs.protocol.InvitationParams params = 3; +inline bool SendInvitationRequest::has_params() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void SendInvitationRequest::set_has_params() { + _has_bits_[0] |= 0x00000004u; +} +inline void SendInvitationRequest::clear_has_params() { + _has_bits_[0] &= ~0x00000004u; +} +inline void SendInvitationRequest::clear_params() { + if (params_ != NULL) params_->::bgs::protocol::InvitationParams::Clear(); + clear_has_params(); +} +inline const ::bgs::protocol::InvitationParams& SendInvitationRequest::params() const { + // @@protoc_insertion_point(field_get:bgs.protocol.SendInvitationRequest.params) + return params_ != NULL ? *params_ : *default_instance_->params_; +} +inline ::bgs::protocol::InvitationParams* SendInvitationRequest::mutable_params() { + set_has_params(); + if (params_ == NULL) params_ = new ::bgs::protocol::InvitationParams; + // @@protoc_insertion_point(field_mutable:bgs.protocol.SendInvitationRequest.params) + return params_; +} +inline ::bgs::protocol::InvitationParams* SendInvitationRequest::release_params() { + clear_has_params(); + ::bgs::protocol::InvitationParams* temp = params_; + params_ = NULL; + return temp; +} +inline void SendInvitationRequest::set_allocated_params(::bgs::protocol::InvitationParams* params) { + delete params_; + params_ = params; + if (params) { + set_has_params(); + } else { + clear_has_params(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.SendInvitationRequest.params) +} + +// optional .bgs.protocol.AccountInfo agent_info = 4; +inline bool SendInvitationRequest::has_agent_info() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void SendInvitationRequest::set_has_agent_info() { + _has_bits_[0] |= 0x00000008u; +} +inline void SendInvitationRequest::clear_has_agent_info() { + _has_bits_[0] &= ~0x00000008u; +} +inline void SendInvitationRequest::clear_agent_info() { + if (agent_info_ != NULL) agent_info_->::bgs::protocol::AccountInfo::Clear(); + clear_has_agent_info(); +} +inline const ::bgs::protocol::AccountInfo& SendInvitationRequest::agent_info() const { + // @@protoc_insertion_point(field_get:bgs.protocol.SendInvitationRequest.agent_info) + return agent_info_ != NULL ? *agent_info_ : *default_instance_->agent_info_; +} +inline ::bgs::protocol::AccountInfo* SendInvitationRequest::mutable_agent_info() { + set_has_agent_info(); + if (agent_info_ == NULL) agent_info_ = new ::bgs::protocol::AccountInfo; + // @@protoc_insertion_point(field_mutable:bgs.protocol.SendInvitationRequest.agent_info) + return agent_info_; +} +inline ::bgs::protocol::AccountInfo* SendInvitationRequest::release_agent_info() { + clear_has_agent_info(); + ::bgs::protocol::AccountInfo* temp = agent_info_; + agent_info_ = NULL; + return temp; +} +inline void SendInvitationRequest::set_allocated_agent_info(::bgs::protocol::AccountInfo* agent_info) { + delete agent_info_; + agent_info_ = agent_info; + if (agent_info) { + set_has_agent_info(); + } else { + clear_has_agent_info(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.SendInvitationRequest.agent_info) +} + +// optional .bgs.protocol.InvitationTarget target = 5; +inline bool SendInvitationRequest::has_target() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void SendInvitationRequest::set_has_target() { + _has_bits_[0] |= 0x00000010u; +} +inline void SendInvitationRequest::clear_has_target() { + _has_bits_[0] &= ~0x00000010u; +} +inline void SendInvitationRequest::clear_target() { + if (target_ != NULL) target_->::bgs::protocol::InvitationTarget::Clear(); + clear_has_target(); +} +inline const ::bgs::protocol::InvitationTarget& SendInvitationRequest::target() const { + // @@protoc_insertion_point(field_get:bgs.protocol.SendInvitationRequest.target) + return target_ != NULL ? *target_ : *default_instance_->target_; +} +inline ::bgs::protocol::InvitationTarget* SendInvitationRequest::mutable_target() { + set_has_target(); + if (target_ == NULL) target_ = new ::bgs::protocol::InvitationTarget; + // @@protoc_insertion_point(field_mutable:bgs.protocol.SendInvitationRequest.target) + return target_; +} +inline ::bgs::protocol::InvitationTarget* SendInvitationRequest::release_target() { + clear_has_target(); + ::bgs::protocol::InvitationTarget* temp = target_; + target_ = NULL; + return temp; +} +inline void SendInvitationRequest::set_allocated_target(::bgs::protocol::InvitationTarget* target) { + delete target_; + target_ = target; + if (target) { + set_has_target(); + } else { + clear_has_target(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.SendInvitationRequest.target) +} + +// ------------------------------------------------------------------- + +// SendInvitationResponse + +// optional .bgs.protocol.Invitation invitation = 2; +inline bool SendInvitationResponse::has_invitation() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SendInvitationResponse::set_has_invitation() { + _has_bits_[0] |= 0x00000001u; +} +inline void SendInvitationResponse::clear_has_invitation() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SendInvitationResponse::clear_invitation() { + if (invitation_ != NULL) invitation_->::bgs::protocol::Invitation::Clear(); + clear_has_invitation(); +} +inline const ::bgs::protocol::Invitation& SendInvitationResponse::invitation() const { + // @@protoc_insertion_point(field_get:bgs.protocol.SendInvitationResponse.invitation) + return invitation_ != NULL ? *invitation_ : *default_instance_->invitation_; +} +inline ::bgs::protocol::Invitation* SendInvitationResponse::mutable_invitation() { + set_has_invitation(); + if (invitation_ == NULL) invitation_ = new ::bgs::protocol::Invitation; + // @@protoc_insertion_point(field_mutable:bgs.protocol.SendInvitationResponse.invitation) + return invitation_; +} +inline ::bgs::protocol::Invitation* SendInvitationResponse::release_invitation() { + clear_has_invitation(); + ::bgs::protocol::Invitation* temp = invitation_; + invitation_ = NULL; + return temp; +} +inline void SendInvitationResponse::set_allocated_invitation(::bgs::protocol::Invitation* invitation) { + delete invitation_; + invitation_ = invitation; + if (invitation) { + set_has_invitation(); + } else { + clear_has_invitation(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.SendInvitationResponse.invitation) +} + +// ------------------------------------------------------------------- + +// UpdateInvitationRequest + +// optional .bgs.protocol.Identity agent_identity = 1; +inline bool UpdateInvitationRequest::has_agent_identity() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void UpdateInvitationRequest::set_has_agent_identity() { + _has_bits_[0] |= 0x00000001u; +} +inline void UpdateInvitationRequest::clear_has_agent_identity() { + _has_bits_[0] &= ~0x00000001u; +} +inline void UpdateInvitationRequest::clear_agent_identity() { + if (agent_identity_ != NULL) agent_identity_->::bgs::protocol::Identity::Clear(); + clear_has_agent_identity(); +} +inline const ::bgs::protocol::Identity& UpdateInvitationRequest::agent_identity() const { + // @@protoc_insertion_point(field_get:bgs.protocol.UpdateInvitationRequest.agent_identity) + return agent_identity_ != NULL ? *agent_identity_ : *default_instance_->agent_identity_; +} +inline ::bgs::protocol::Identity* UpdateInvitationRequest::mutable_agent_identity() { + set_has_agent_identity(); + if (agent_identity_ == NULL) agent_identity_ = new ::bgs::protocol::Identity; + // @@protoc_insertion_point(field_mutable:bgs.protocol.UpdateInvitationRequest.agent_identity) + return agent_identity_; +} +inline ::bgs::protocol::Identity* UpdateInvitationRequest::release_agent_identity() { + clear_has_agent_identity(); + ::bgs::protocol::Identity* temp = agent_identity_; + agent_identity_ = NULL; + return temp; +} +inline void UpdateInvitationRequest::set_allocated_agent_identity(::bgs::protocol::Identity* agent_identity) { + delete agent_identity_; + agent_identity_ = agent_identity; + if (agent_identity) { + set_has_agent_identity(); + } else { + clear_has_agent_identity(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.UpdateInvitationRequest.agent_identity) +} + +// required fixed64 invitation_id = 2; +inline bool UpdateInvitationRequest::has_invitation_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void UpdateInvitationRequest::set_has_invitation_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void UpdateInvitationRequest::clear_has_invitation_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void UpdateInvitationRequest::clear_invitation_id() { + invitation_id_ = GOOGLE_ULONGLONG(0); + clear_has_invitation_id(); +} +inline ::google::protobuf::uint64 UpdateInvitationRequest::invitation_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.UpdateInvitationRequest.invitation_id) + return invitation_id_; +} +inline void UpdateInvitationRequest::set_invitation_id(::google::protobuf::uint64 value) { + set_has_invitation_id(); + invitation_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.UpdateInvitationRequest.invitation_id) +} + +// required .bgs.protocol.InvitationParams params = 3; +inline bool UpdateInvitationRequest::has_params() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void UpdateInvitationRequest::set_has_params() { + _has_bits_[0] |= 0x00000004u; +} +inline void UpdateInvitationRequest::clear_has_params() { + _has_bits_[0] &= ~0x00000004u; +} +inline void UpdateInvitationRequest::clear_params() { + if (params_ != NULL) params_->::bgs::protocol::InvitationParams::Clear(); + clear_has_params(); +} +inline const ::bgs::protocol::InvitationParams& UpdateInvitationRequest::params() const { + // @@protoc_insertion_point(field_get:bgs.protocol.UpdateInvitationRequest.params) + return params_ != NULL ? *params_ : *default_instance_->params_; +} +inline ::bgs::protocol::InvitationParams* UpdateInvitationRequest::mutable_params() { + set_has_params(); + if (params_ == NULL) params_ = new ::bgs::protocol::InvitationParams; + // @@protoc_insertion_point(field_mutable:bgs.protocol.UpdateInvitationRequest.params) + return params_; +} +inline ::bgs::protocol::InvitationParams* UpdateInvitationRequest::release_params() { + clear_has_params(); + ::bgs::protocol::InvitationParams* temp = params_; + params_ = NULL; + return temp; +} +inline void UpdateInvitationRequest::set_allocated_params(::bgs::protocol::InvitationParams* params) { + delete params_; + params_ = params; + if (params) { + set_has_params(); + } else { + clear_has_params(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.UpdateInvitationRequest.params) +} + +// ------------------------------------------------------------------- + +// GenericInvitationRequest + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool GenericInvitationRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GenericInvitationRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void GenericInvitationRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GenericInvitationRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& GenericInvitationRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.GenericInvitationRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* GenericInvitationRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.GenericInvitationRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* GenericInvitationRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void GenericInvitationRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.GenericInvitationRequest.agent_id) +} + +// optional .bgs.protocol.EntityId target_id = 2; +inline bool GenericInvitationRequest::has_target_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GenericInvitationRequest::set_has_target_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void GenericInvitationRequest::clear_has_target_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GenericInvitationRequest::clear_target_id() { + if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear(); + clear_has_target_id(); +} +inline const ::bgs::protocol::EntityId& GenericInvitationRequest::target_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.GenericInvitationRequest.target_id) + return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_; +} +inline ::bgs::protocol::EntityId* GenericInvitationRequest::mutable_target_id() { + set_has_target_id(); + if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.GenericInvitationRequest.target_id) + return target_id_; +} +inline ::bgs::protocol::EntityId* GenericInvitationRequest::release_target_id() { + clear_has_target_id(); + ::bgs::protocol::EntityId* temp = target_id_; + target_id_ = NULL; + return temp; +} +inline void GenericInvitationRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) { + delete target_id_; + target_id_ = target_id; + if (target_id) { + set_has_target_id(); + } else { + clear_has_target_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.GenericInvitationRequest.target_id) +} + +// required fixed64 invitation_id = 3; +inline bool GenericInvitationRequest::has_invitation_id() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GenericInvitationRequest::set_has_invitation_id() { + _has_bits_[0] |= 0x00000004u; +} +inline void GenericInvitationRequest::clear_has_invitation_id() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GenericInvitationRequest::clear_invitation_id() { + invitation_id_ = GOOGLE_ULONGLONG(0); + clear_has_invitation_id(); +} +inline ::google::protobuf::uint64 GenericInvitationRequest::invitation_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.GenericInvitationRequest.invitation_id) + return invitation_id_; +} +inline void GenericInvitationRequest::set_invitation_id(::google::protobuf::uint64 value) { + set_has_invitation_id(); + invitation_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.GenericInvitationRequest.invitation_id) +} + +// optional string invitee_name = 4; +inline bool GenericInvitationRequest::has_invitee_name() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void GenericInvitationRequest::set_has_invitee_name() { + _has_bits_[0] |= 0x00000008u; +} +inline void GenericInvitationRequest::clear_has_invitee_name() { + _has_bits_[0] &= ~0x00000008u; +} +inline void GenericInvitationRequest::clear_invitee_name() { + if (invitee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitee_name_->clear(); + } + clear_has_invitee_name(); +} +inline const ::std::string& GenericInvitationRequest::invitee_name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.GenericInvitationRequest.invitee_name) + return *invitee_name_; +} +inline void GenericInvitationRequest::set_invitee_name(const ::std::string& value) { + set_has_invitee_name(); + if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitee_name_ = new ::std::string; + } + invitee_name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.GenericInvitationRequest.invitee_name) +} +inline void GenericInvitationRequest::set_invitee_name(const char* value) { + set_has_invitee_name(); + if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitee_name_ = new ::std::string; + } + invitee_name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.GenericInvitationRequest.invitee_name) +} +inline void GenericInvitationRequest::set_invitee_name(const char* value, size_t size) { + set_has_invitee_name(); + if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitee_name_ = new ::std::string; + } + invitee_name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.GenericInvitationRequest.invitee_name) +} +inline ::std::string* GenericInvitationRequest::mutable_invitee_name() { + set_has_invitee_name(); + if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + invitee_name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.GenericInvitationRequest.invitee_name) + return invitee_name_; +} +inline ::std::string* GenericInvitationRequest::release_invitee_name() { + clear_has_invitee_name(); + if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = invitee_name_; + invitee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void GenericInvitationRequest::set_allocated_invitee_name(::std::string* invitee_name) { + if (invitee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete invitee_name_; + } + if (invitee_name) { + set_has_invitee_name(); + invitee_name_ = invitee_name; + } else { + clear_has_invitee_name(); + invitee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.GenericInvitationRequest.invitee_name) +} + +// optional string inviter_name = 5; +inline bool GenericInvitationRequest::has_inviter_name() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void GenericInvitationRequest::set_has_inviter_name() { + _has_bits_[0] |= 0x00000010u; +} +inline void GenericInvitationRequest::clear_has_inviter_name() { + _has_bits_[0] &= ~0x00000010u; +} +inline void GenericInvitationRequest::clear_inviter_name() { + if (inviter_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + inviter_name_->clear(); + } + clear_has_inviter_name(); +} +inline const ::std::string& GenericInvitationRequest::inviter_name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.GenericInvitationRequest.inviter_name) + return *inviter_name_; +} +inline void GenericInvitationRequest::set_inviter_name(const ::std::string& value) { + set_has_inviter_name(); + if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + inviter_name_ = new ::std::string; + } + inviter_name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.GenericInvitationRequest.inviter_name) +} +inline void GenericInvitationRequest::set_inviter_name(const char* value) { + set_has_inviter_name(); + if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + inviter_name_ = new ::std::string; + } + inviter_name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.GenericInvitationRequest.inviter_name) +} +inline void GenericInvitationRequest::set_inviter_name(const char* value, size_t size) { + set_has_inviter_name(); + if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + inviter_name_ = new ::std::string; + } + inviter_name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.GenericInvitationRequest.inviter_name) +} +inline ::std::string* GenericInvitationRequest::mutable_inviter_name() { + set_has_inviter_name(); + if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + inviter_name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.GenericInvitationRequest.inviter_name) + return inviter_name_; +} +inline ::std::string* GenericInvitationRequest::release_inviter_name() { + clear_has_inviter_name(); + if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = inviter_name_; + inviter_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void GenericInvitationRequest::set_allocated_inviter_name(::std::string* inviter_name) { + if (inviter_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete inviter_name_; + } + if (inviter_name) { + set_has_inviter_name(); + inviter_name_ = inviter_name; + } else { + clear_has_inviter_name(); + inviter_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.GenericInvitationRequest.inviter_name) +} + +// repeated uint32 previous_role = 6 [packed = true]; +inline int GenericInvitationRequest::previous_role_size() const { + return previous_role_.size(); +} +inline void GenericInvitationRequest::clear_previous_role() { + previous_role_.Clear(); +} +inline ::google::protobuf::uint32 GenericInvitationRequest::previous_role(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.GenericInvitationRequest.previous_role) + return previous_role_.Get(index); +} +inline void GenericInvitationRequest::set_previous_role(int index, ::google::protobuf::uint32 value) { + previous_role_.Set(index, value); + // @@protoc_insertion_point(field_set:bgs.protocol.GenericInvitationRequest.previous_role) +} +inline void GenericInvitationRequest::add_previous_role(::google::protobuf::uint32 value) { + previous_role_.Add(value); + // @@protoc_insertion_point(field_add:bgs.protocol.GenericInvitationRequest.previous_role) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +GenericInvitationRequest::previous_role() const { + // @@protoc_insertion_point(field_list:bgs.protocol.GenericInvitationRequest.previous_role) + return previous_role_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +GenericInvitationRequest::mutable_previous_role() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.GenericInvitationRequest.previous_role) + return &previous_role_; +} + +// repeated uint32 desired_role = 7 [packed = true]; +inline int GenericInvitationRequest::desired_role_size() const { + return desired_role_.size(); +} +inline void GenericInvitationRequest::clear_desired_role() { + desired_role_.Clear(); +} +inline ::google::protobuf::uint32 GenericInvitationRequest::desired_role(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.GenericInvitationRequest.desired_role) + return desired_role_.Get(index); +} +inline void GenericInvitationRequest::set_desired_role(int index, ::google::protobuf::uint32 value) { + desired_role_.Set(index, value); + // @@protoc_insertion_point(field_set:bgs.protocol.GenericInvitationRequest.desired_role) +} +inline void GenericInvitationRequest::add_desired_role(::google::protobuf::uint32 value) { + desired_role_.Add(value); + // @@protoc_insertion_point(field_add:bgs.protocol.GenericInvitationRequest.desired_role) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +GenericInvitationRequest::desired_role() const { + // @@protoc_insertion_point(field_list:bgs.protocol.GenericInvitationRequest.desired_role) + return desired_role_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +GenericInvitationRequest::mutable_desired_role() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.GenericInvitationRequest.desired_role) + return &desired_role_; +} + +// optional uint32 reason = 8; +inline bool GenericInvitationRequest::has_reason() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void GenericInvitationRequest::set_has_reason() { + _has_bits_[0] |= 0x00000080u; +} +inline void GenericInvitationRequest::clear_has_reason() { + _has_bits_[0] &= ~0x00000080u; +} +inline void GenericInvitationRequest::clear_reason() { + reason_ = 0u; + clear_has_reason(); +} +inline ::google::protobuf::uint32 GenericInvitationRequest::reason() const { + // @@protoc_insertion_point(field_get:bgs.protocol.GenericInvitationRequest.reason) + return reason_; +} +inline void GenericInvitationRequest::set_reason(::google::protobuf::uint32 value) { + set_has_reason(); + reason_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.GenericInvitationRequest.reason) +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_invitation_5ftypes_2eproto__INCLUDED diff --git a/src/server/proto/Client/notification_types.pb.cc b/src/server/proto/Client/notification_types.pb.cc new file mode 100644 index 00000000000..1f354557075 --- /dev/null +++ b/src/server/proto/Client/notification_types.pb.cc @@ -0,0 +1,1490 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: notification_types.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "notification_types.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { +namespace notification { +namespace v1 { + +namespace { + +const ::google::protobuf::Descriptor* Target_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Target_reflection_ = NULL; +const ::google::protobuf::Descriptor* Subscription_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Subscription_reflection_ = NULL; +const ::google::protobuf::Descriptor* Notification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Notification_reflection_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_notification_5ftypes_2eproto() { + protobuf_AddDesc_notification_5ftypes_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "notification_types.proto"); + GOOGLE_CHECK(file != NULL); + Target_descriptor_ = file->message_type(0); + static const int Target_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Target, identity_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Target, type_), + }; + Target_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Target_descriptor_, + Target::default_instance_, + Target_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Target, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Target, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Target)); + Subscription_descriptor_ = file->message_type(1); + static const int Subscription_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Subscription, target_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Subscription, subscriber_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Subscription, delivery_required_), + }; + Subscription_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Subscription_descriptor_, + Subscription::default_instance_, + Subscription_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Subscription, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Subscription, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Subscription)); + Notification_descriptor_ = file->message_type(2); + static const int Notification_offsets_[10] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Notification, sender_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Notification, target_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Notification, type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Notification, attribute_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Notification, sender_account_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Notification, target_account_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Notification, sender_battle_tag_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Notification, target_battle_tag_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Notification, peer_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Notification, forwarding_identity_), + }; + Notification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Notification_descriptor_, + Notification::default_instance_, + Notification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Notification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Notification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Notification)); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_notification_5ftypes_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Target_descriptor_, &Target::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Subscription_descriptor_, &Subscription::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Notification_descriptor_, &Notification::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_notification_5ftypes_2eproto() { + delete Target::default_instance_; + delete Target_reflection_; + delete Subscription::default_instance_; + delete Subscription_reflection_; + delete Notification::default_instance_; + delete Notification_reflection_; +} + +void protobuf_AddDesc_notification_5ftypes_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::bgs::protocol::account::v1::protobuf_AddDesc_account_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\030notification_types.proto\022\034bgs.protocol" + ".notification.v1\032\023account_types.proto\032\025a" + "ttribute_types.proto\032\022entity_types.proto" + "\032\017rpc_types.proto\"K\n\006Target\0223\n\010identity\030" + "\001 \001(\0132!.bgs.protocol.account.v1.Identity" + "\022\014\n\004type\030\002 \001(\t\"\235\001\n\014Subscription\0224\n\006targe" + "t\030\001 \003(\0132$.bgs.protocol.notification.v1.T" + "arget\0225\n\nsubscriber\030\002 \001(\0132!.bgs.protocol" + ".account.v1.Identity\022 \n\021delivery_require" + "d\030\003 \001(\010:\005false\"\241\003\n\014Notification\022)\n\tsende" + "r_id\030\001 \001(\0132\026.bgs.protocol.EntityId\022)\n\tta" + "rget_id\030\002 \002(\0132\026.bgs.protocol.EntityId\022\014\n" + "\004type\030\003 \002(\t\022*\n\tattribute\030\004 \003(\0132\027.bgs.pro" + "tocol.Attribute\0221\n\021sender_account_id\030\005 \001" + "(\0132\026.bgs.protocol.EntityId\0221\n\021target_acc" + "ount_id\030\006 \001(\0132\026.bgs.protocol.EntityId\022\031\n" + "\021sender_battle_tag\030\007 \001(\t\022\031\n\021target_battl" + "e_tag\030\010 \001(\t\022%\n\004peer\030\t \001(\0132\027.bgs.protocol" + ".ProcessId\022>\n\023forwarding_identity\030\n \001(\0132" + "!.bgs.protocol.account.v1.IdentityB\002H\001", 798); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "notification_types.proto", &protobuf_RegisterTypes); + Target::default_instance_ = new Target(); + Subscription::default_instance_ = new Subscription(); + Notification::default_instance_ = new Notification(); + Target::default_instance_->InitAsDefaultInstance(); + Subscription::default_instance_->InitAsDefaultInstance(); + Notification::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_notification_5ftypes_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_notification_5ftypes_2eproto { + StaticDescriptorInitializer_notification_5ftypes_2eproto() { + protobuf_AddDesc_notification_5ftypes_2eproto(); + } +} static_descriptor_initializer_notification_5ftypes_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int Target::kIdentityFieldNumber; +const int Target::kTypeFieldNumber; +#endif // !_MSC_VER + +Target::Target() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.notification.v1.Target) +} + +void Target::InitAsDefaultInstance() { + identity_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance()); +} + +Target::Target(const Target& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.notification.v1.Target) +} + +void Target::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + identity_ = NULL; + type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Target::~Target() { + // @@protoc_insertion_point(destructor:bgs.protocol.notification.v1.Target) + SharedDtor(); +} + +void Target::SharedDtor() { + if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete type_; + } + if (this != default_instance_) { + delete identity_; + } +} + +void Target::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Target::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Target_descriptor_; +} + +const Target& Target::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_notification_5ftypes_2eproto(); + return *default_instance_; +} + +Target* Target::default_instance_ = NULL; + +Target* Target::New() const { + return new Target; +} + +void Target::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_identity()) { + if (identity_ != NULL) identity_->::bgs::protocol::account::v1::Identity::Clear(); + } + if (has_type()) { + if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + type_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Target::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.notification.v1.Target) + 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 .bgs.protocol.account.v1.Identity identity = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_identity())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_type; + break; + } + + // optional string type = 2; + case 2: { + if (tag == 18) { + parse_type: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_type())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->type().data(), this->type().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "type"); + } 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:bgs.protocol.notification.v1.Target) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.notification.v1.Target) + return false; +#undef DO_ +} + +void Target::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.notification.v1.Target) + // optional .bgs.protocol.account.v1.Identity identity = 1; + if (has_identity()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->identity(), output); + } + + // optional string type = 2; + if (has_type()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->type().data(), this->type().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "type"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->type(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.notification.v1.Target) +} + +::google::protobuf::uint8* Target::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.notification.v1.Target) + // optional .bgs.protocol.account.v1.Identity identity = 1; + if (has_identity()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->identity(), target); + } + + // optional string type = 2; + if (has_type()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->type().data(), this->type().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "type"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->type(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.notification.v1.Target) + return target; +} + +int Target::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.account.v1.Identity identity = 1; + if (has_identity()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->identity()); + } + + // optional string type = 2; + if (has_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->type()); + } + + } + 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 Target::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Target* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Target::MergeFrom(const Target& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_identity()) { + mutable_identity()->::bgs::protocol::account::v1::Identity::MergeFrom(from.identity()); + } + if (from.has_type()) { + set_type(from.type()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Target::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Target::CopyFrom(const Target& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Target::IsInitialized() const { + + if (has_identity()) { + if (!this->identity().IsInitialized()) return false; + } + return true; +} + +void Target::Swap(Target* other) { + if (other != this) { + std::swap(identity_, other->identity_); + std::swap(type_, other->type_); + 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 Target::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Target_descriptor_; + metadata.reflection = Target_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int Subscription::kTargetFieldNumber; +const int Subscription::kSubscriberFieldNumber; +const int Subscription::kDeliveryRequiredFieldNumber; +#endif // !_MSC_VER + +Subscription::Subscription() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.notification.v1.Subscription) +} + +void Subscription::InitAsDefaultInstance() { + subscriber_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance()); +} + +Subscription::Subscription(const Subscription& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.notification.v1.Subscription) +} + +void Subscription::SharedCtor() { + _cached_size_ = 0; + subscriber_ = NULL; + delivery_required_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Subscription::~Subscription() { + // @@protoc_insertion_point(destructor:bgs.protocol.notification.v1.Subscription) + SharedDtor(); +} + +void Subscription::SharedDtor() { + if (this != default_instance_) { + delete subscriber_; + } +} + +void Subscription::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Subscription::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Subscription_descriptor_; +} + +const Subscription& Subscription::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_notification_5ftypes_2eproto(); + return *default_instance_; +} + +Subscription* Subscription::default_instance_ = NULL; + +Subscription* Subscription::New() const { + return new Subscription; +} + +void Subscription::Clear() { + if (_has_bits_[0 / 32] & 6) { + if (has_subscriber()) { + if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear(); + } + delivery_required_ = false; + } + target_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Subscription::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.notification.v1.Subscription) + 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 .bgs.protocol.notification.v1.Target target = 1; + case 1: { + if (tag == 10) { + parse_target: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_target())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_target; + if (input->ExpectTag(18)) goto parse_subscriber; + break; + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 2; + case 2: { + if (tag == 18) { + parse_subscriber: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_subscriber())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_delivery_required; + break; + } + + // optional bool delivery_required = 3 [default = false]; + case 3: { + if (tag == 24) { + parse_delivery_required: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &delivery_required_))); + set_has_delivery_required(); + } 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:bgs.protocol.notification.v1.Subscription) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.notification.v1.Subscription) + return false; +#undef DO_ +} + +void Subscription::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.notification.v1.Subscription) + // repeated .bgs.protocol.notification.v1.Target target = 1; + for (int i = 0; i < this->target_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->target(i), output); + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 2; + if (has_subscriber()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->subscriber(), output); + } + + // optional bool delivery_required = 3 [default = false]; + if (has_delivery_required()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->delivery_required(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.notification.v1.Subscription) +} + +::google::protobuf::uint8* Subscription::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.notification.v1.Subscription) + // repeated .bgs.protocol.notification.v1.Target target = 1; + for (int i = 0; i < this->target_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->target(i), target); + } + + // optional .bgs.protocol.account.v1.Identity subscriber = 2; + if (has_subscriber()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->subscriber(), target); + } + + // optional bool delivery_required = 3 [default = false]; + if (has_delivery_required()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->delivery_required(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.notification.v1.Subscription) + return target; +} + +int Subscription::ByteSize() const { + int total_size = 0; + + if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) { + // optional .bgs.protocol.account.v1.Identity subscriber = 2; + if (has_subscriber()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->subscriber()); + } + + // optional bool delivery_required = 3 [default = false]; + if (has_delivery_required()) { + total_size += 1 + 1; + } + + } + // repeated .bgs.protocol.notification.v1.Target target = 1; + total_size += 1 * this->target_size(); + for (int i = 0; i < this->target_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->target(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 Subscription::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Subscription* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Subscription::MergeFrom(const Subscription& from) { + GOOGLE_CHECK_NE(&from, this); + target_.MergeFrom(from.target_); + if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) { + if (from.has_subscriber()) { + mutable_subscriber()->::bgs::protocol::account::v1::Identity::MergeFrom(from.subscriber()); + } + if (from.has_delivery_required()) { + set_delivery_required(from.delivery_required()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Subscription::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Subscription::CopyFrom(const Subscription& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Subscription::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->target())) return false; + if (has_subscriber()) { + if (!this->subscriber().IsInitialized()) return false; + } + return true; +} + +void Subscription::Swap(Subscription* other) { + if (other != this) { + target_.Swap(&other->target_); + std::swap(subscriber_, other->subscriber_); + std::swap(delivery_required_, other->delivery_required_); + 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 Subscription::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Subscription_descriptor_; + metadata.reflection = Subscription_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int Notification::kSenderIdFieldNumber; +const int Notification::kTargetIdFieldNumber; +const int Notification::kTypeFieldNumber; +const int Notification::kAttributeFieldNumber; +const int Notification::kSenderAccountIdFieldNumber; +const int Notification::kTargetAccountIdFieldNumber; +const int Notification::kSenderBattleTagFieldNumber; +const int Notification::kTargetBattleTagFieldNumber; +const int Notification::kPeerFieldNumber; +const int Notification::kForwardingIdentityFieldNumber; +#endif // !_MSC_VER + +Notification::Notification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.notification.v1.Notification) +} + +void Notification::InitAsDefaultInstance() { + sender_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + sender_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + target_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + peer_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance()); + forwarding_identity_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance()); +} + +Notification::Notification(const Notification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.notification.v1.Notification) +} + +void Notification::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + sender_id_ = NULL; + target_id_ = NULL; + type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + sender_account_id_ = NULL; + target_account_id_ = NULL; + sender_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + target_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + peer_ = NULL; + forwarding_identity_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Notification::~Notification() { + // @@protoc_insertion_point(destructor:bgs.protocol.notification.v1.Notification) + SharedDtor(); +} + +void Notification::SharedDtor() { + if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete type_; + } + if (sender_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete sender_battle_tag_; + } + if (target_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete target_battle_tag_; + } + if (this != default_instance_) { + delete sender_id_; + delete target_id_; + delete sender_account_id_; + delete target_account_id_; + delete peer_; + delete forwarding_identity_; + } +} + +void Notification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Notification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Notification_descriptor_; +} + +const Notification& Notification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_notification_5ftypes_2eproto(); + return *default_instance_; +} + +Notification* Notification::default_instance_ = NULL; + +Notification* Notification::New() const { + return new Notification; +} + +void Notification::Clear() { + if (_has_bits_[0 / 32] & 247) { + if (has_sender_id()) { + if (sender_id_ != NULL) sender_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_target_id()) { + if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_type()) { + if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + type_->clear(); + } + } + if (has_sender_account_id()) { + if (sender_account_id_ != NULL) sender_account_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_target_account_id()) { + if (target_account_id_ != NULL) target_account_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_sender_battle_tag()) { + if (sender_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sender_battle_tag_->clear(); + } + } + if (has_target_battle_tag()) { + if (target_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + target_battle_tag_->clear(); + } + } + } + if (_has_bits_[8 / 32] & 768) { + if (has_peer()) { + if (peer_ != NULL) peer_->::bgs::protocol::ProcessId::Clear(); + } + if (has_forwarding_identity()) { + if (forwarding_identity_ != NULL) forwarding_identity_->::bgs::protocol::account::v1::Identity::Clear(); + } + } + attribute_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Notification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.notification.v1.Notification) + 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 .bgs.protocol.EntityId sender_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_sender_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_target_id; + break; + } + + // required .bgs.protocol.EntityId target_id = 2; + case 2: { + if (tag == 18) { + parse_target_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_target_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_type; + break; + } + + // required string type = 3; + case 3: { + if (tag == 26) { + parse_type: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_type())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->type().data(), this->type().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "type"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_attribute; + break; + } + + // repeated .bgs.protocol.Attribute attribute = 4; + case 4: { + if (tag == 34) { + parse_attribute: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_attribute())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_attribute; + if (input->ExpectTag(42)) goto parse_sender_account_id; + break; + } + + // optional .bgs.protocol.EntityId sender_account_id = 5; + case 5: { + if (tag == 42) { + parse_sender_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_sender_account_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(50)) goto parse_target_account_id; + break; + } + + // optional .bgs.protocol.EntityId target_account_id = 6; + case 6: { + if (tag == 50) { + parse_target_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_target_account_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(58)) goto parse_sender_battle_tag; + break; + } + + // optional string sender_battle_tag = 7; + case 7: { + if (tag == 58) { + parse_sender_battle_tag: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_sender_battle_tag())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->sender_battle_tag().data(), this->sender_battle_tag().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "sender_battle_tag"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(66)) goto parse_target_battle_tag; + break; + } + + // optional string target_battle_tag = 8; + case 8: { + if (tag == 66) { + parse_target_battle_tag: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_target_battle_tag())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->target_battle_tag().data(), this->target_battle_tag().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "target_battle_tag"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(74)) goto parse_peer; + break; + } + + // optional .bgs.protocol.ProcessId peer = 9; + case 9: { + if (tag == 74) { + parse_peer: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_peer())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(82)) goto parse_forwarding_identity; + break; + } + + // optional .bgs.protocol.account.v1.Identity forwarding_identity = 10; + case 10: { + if (tag == 82) { + parse_forwarding_identity: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_forwarding_identity())); + } 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:bgs.protocol.notification.v1.Notification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.notification.v1.Notification) + return false; +#undef DO_ +} + +void Notification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.notification.v1.Notification) + // optional .bgs.protocol.EntityId sender_id = 1; + if (has_sender_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->sender_id(), output); + } + + // required .bgs.protocol.EntityId target_id = 2; + if (has_target_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->target_id(), output); + } + + // required string type = 3; + if (has_type()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->type().data(), this->type().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "type"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->type(), output); + } + + // repeated .bgs.protocol.Attribute attribute = 4; + for (int i = 0; i < this->attribute_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->attribute(i), output); + } + + // optional .bgs.protocol.EntityId sender_account_id = 5; + if (has_sender_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, this->sender_account_id(), output); + } + + // optional .bgs.protocol.EntityId target_account_id = 6; + if (has_target_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, this->target_account_id(), output); + } + + // optional string sender_battle_tag = 7; + if (has_sender_battle_tag()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->sender_battle_tag().data(), this->sender_battle_tag().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "sender_battle_tag"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 7, this->sender_battle_tag(), output); + } + + // optional string target_battle_tag = 8; + if (has_target_battle_tag()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->target_battle_tag().data(), this->target_battle_tag().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "target_battle_tag"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 8, this->target_battle_tag(), output); + } + + // optional .bgs.protocol.ProcessId peer = 9; + if (has_peer()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 9, this->peer(), output); + } + + // optional .bgs.protocol.account.v1.Identity forwarding_identity = 10; + if (has_forwarding_identity()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 10, this->forwarding_identity(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.notification.v1.Notification) +} + +::google::protobuf::uint8* Notification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.notification.v1.Notification) + // optional .bgs.protocol.EntityId sender_id = 1; + if (has_sender_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->sender_id(), target); + } + + // required .bgs.protocol.EntityId target_id = 2; + if (has_target_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->target_id(), target); + } + + // required string type = 3; + if (has_type()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->type().data(), this->type().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "type"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->type(), target); + } + + // repeated .bgs.protocol.Attribute attribute = 4; + for (int i = 0; i < this->attribute_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->attribute(i), target); + } + + // optional .bgs.protocol.EntityId sender_account_id = 5; + if (has_sender_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 5, this->sender_account_id(), target); + } + + // optional .bgs.protocol.EntityId target_account_id = 6; + if (has_target_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 6, this->target_account_id(), target); + } + + // optional string sender_battle_tag = 7; + if (has_sender_battle_tag()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->sender_battle_tag().data(), this->sender_battle_tag().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "sender_battle_tag"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 7, this->sender_battle_tag(), target); + } + + // optional string target_battle_tag = 8; + if (has_target_battle_tag()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->target_battle_tag().data(), this->target_battle_tag().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "target_battle_tag"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 8, this->target_battle_tag(), target); + } + + // optional .bgs.protocol.ProcessId peer = 9; + if (has_peer()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 9, this->peer(), target); + } + + // optional .bgs.protocol.account.v1.Identity forwarding_identity = 10; + if (has_forwarding_identity()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 10, this->forwarding_identity(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.notification.v1.Notification) + return target; +} + +int Notification::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId sender_id = 1; + if (has_sender_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->sender_id()); + } + + // required .bgs.protocol.EntityId target_id = 2; + if (has_target_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->target_id()); + } + + // required string type = 3; + if (has_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->type()); + } + + // optional .bgs.protocol.EntityId sender_account_id = 5; + if (has_sender_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->sender_account_id()); + } + + // optional .bgs.protocol.EntityId target_account_id = 6; + if (has_target_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->target_account_id()); + } + + // optional string sender_battle_tag = 7; + if (has_sender_battle_tag()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->sender_battle_tag()); + } + + // optional string target_battle_tag = 8; + if (has_target_battle_tag()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->target_battle_tag()); + } + + } + if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + // optional .bgs.protocol.ProcessId peer = 9; + if (has_peer()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->peer()); + } + + // optional .bgs.protocol.account.v1.Identity forwarding_identity = 10; + if (has_forwarding_identity()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->forwarding_identity()); + } + + } + // repeated .bgs.protocol.Attribute attribute = 4; + total_size += 1 * this->attribute_size(); + for (int i = 0; i < this->attribute_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->attribute(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 Notification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Notification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Notification::MergeFrom(const Notification& from) { + GOOGLE_CHECK_NE(&from, this); + attribute_.MergeFrom(from.attribute_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_sender_id()) { + mutable_sender_id()->::bgs::protocol::EntityId::MergeFrom(from.sender_id()); + } + if (from.has_target_id()) { + mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id()); + } + if (from.has_type()) { + set_type(from.type()); + } + if (from.has_sender_account_id()) { + mutable_sender_account_id()->::bgs::protocol::EntityId::MergeFrom(from.sender_account_id()); + } + if (from.has_target_account_id()) { + mutable_target_account_id()->::bgs::protocol::EntityId::MergeFrom(from.target_account_id()); + } + if (from.has_sender_battle_tag()) { + set_sender_battle_tag(from.sender_battle_tag()); + } + if (from.has_target_battle_tag()) { + set_target_battle_tag(from.target_battle_tag()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from.has_peer()) { + mutable_peer()->::bgs::protocol::ProcessId::MergeFrom(from.peer()); + } + if (from.has_forwarding_identity()) { + mutable_forwarding_identity()->::bgs::protocol::account::v1::Identity::MergeFrom(from.forwarding_identity()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Notification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Notification::CopyFrom(const Notification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Notification::IsInitialized() const { + if ((_has_bits_[0] & 0x00000006) != 0x00000006) return false; + + if (has_sender_id()) { + if (!this->sender_id().IsInitialized()) return false; + } + if (has_target_id()) { + if (!this->target_id().IsInitialized()) return false; + } + if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false; + if (has_sender_account_id()) { + if (!this->sender_account_id().IsInitialized()) return false; + } + if (has_target_account_id()) { + if (!this->target_account_id().IsInitialized()) return false; + } + if (has_peer()) { + if (!this->peer().IsInitialized()) return false; + } + if (has_forwarding_identity()) { + if (!this->forwarding_identity().IsInitialized()) return false; + } + return true; +} + +void Notification::Swap(Notification* other) { + if (other != this) { + std::swap(sender_id_, other->sender_id_); + std::swap(target_id_, other->target_id_); + std::swap(type_, other->type_); + attribute_.Swap(&other->attribute_); + std::swap(sender_account_id_, other->sender_account_id_); + std::swap(target_account_id_, other->target_account_id_); + std::swap(sender_battle_tag_, other->sender_battle_tag_); + std::swap(target_battle_tag_, other->target_battle_tag_); + std::swap(peer_, other->peer_); + std::swap(forwarding_identity_, other->forwarding_identity_); + 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 Notification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Notification_descriptor_; + metadata.reflection = Notification_reflection_; + return metadata; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace notification +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/notification_types.pb.h b/src/server/proto/Client/notification_types.pb.h new file mode 100644 index 00000000000..e0cf8d6c157 --- /dev/null +++ b/src/server/proto/Client/notification_types.pb.h @@ -0,0 +1,1200 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: notification_types.proto + +#ifndef PROTOBUF_notification_5ftypes_2eproto__INCLUDED +#define PROTOBUF_notification_5ftypes_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include "account_types.pb.h" +#include "attribute_types.pb.h" +#include "entity_types.pb.h" +#include "rpc_types.pb.h" +#include "Define.h" // for TRINITY_SHARED_API +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { +namespace notification { +namespace v1 { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_notification_5ftypes_2eproto(); +void protobuf_AssignDesc_notification_5ftypes_2eproto(); +void protobuf_ShutdownFile_notification_5ftypes_2eproto(); + +class Target; +class Subscription; +class Notification; + +// =================================================================== + +class TC_SHARED_API Target : public ::google::protobuf::Message { + public: + Target(); + virtual ~Target(); + + Target(const Target& from); + + inline Target& operator=(const Target& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Target& default_instance(); + + void Swap(Target* other); + + // implements Message ---------------------------------------------- + + Target* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Target& from); + void MergeFrom(const Target& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.account.v1.Identity identity = 1; + inline bool has_identity() const; + inline void clear_identity(); + static const int kIdentityFieldNumber = 1; + inline const ::bgs::protocol::account::v1::Identity& identity() const; + inline ::bgs::protocol::account::v1::Identity* mutable_identity(); + inline ::bgs::protocol::account::v1::Identity* release_identity(); + inline void set_allocated_identity(::bgs::protocol::account::v1::Identity* identity); + + // optional string type = 2; + inline bool has_type() const; + inline void clear_type(); + static const int kTypeFieldNumber = 2; + inline const ::std::string& type() const; + inline void set_type(const ::std::string& value); + inline void set_type(const char* value); + inline void set_type(const char* value, size_t size); + inline ::std::string* mutable_type(); + inline ::std::string* release_type(); + inline void set_allocated_type(::std::string* type); + + // @@protoc_insertion_point(class_scope:bgs.protocol.notification.v1.Target) + private: + inline void set_has_identity(); + inline void clear_has_identity(); + inline void set_has_type(); + inline void clear_has_type(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::account::v1::Identity* identity_; + ::std::string* type_; + friend void TC_SHARED_API protobuf_AddDesc_notification_5ftypes_2eproto(); + friend void protobuf_AssignDesc_notification_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_notification_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static Target* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API Subscription : public ::google::protobuf::Message { + public: + Subscription(); + virtual ~Subscription(); + + Subscription(const Subscription& from); + + inline Subscription& operator=(const Subscription& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Subscription& default_instance(); + + void Swap(Subscription* other); + + // implements Message ---------------------------------------------- + + Subscription* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Subscription& from); + void MergeFrom(const Subscription& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.notification.v1.Target target = 1; + inline int target_size() const; + inline void clear_target(); + static const int kTargetFieldNumber = 1; + inline const ::bgs::protocol::notification::v1::Target& target(int index) const; + inline ::bgs::protocol::notification::v1::Target* mutable_target(int index); + inline ::bgs::protocol::notification::v1::Target* add_target(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::notification::v1::Target >& + target() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::notification::v1::Target >* + mutable_target(); + + // optional .bgs.protocol.account.v1.Identity subscriber = 2; + inline bool has_subscriber() const; + inline void clear_subscriber(); + static const int kSubscriberFieldNumber = 2; + inline const ::bgs::protocol::account::v1::Identity& subscriber() const; + inline ::bgs::protocol::account::v1::Identity* mutable_subscriber(); + inline ::bgs::protocol::account::v1::Identity* release_subscriber(); + inline void set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber); + + // optional bool delivery_required = 3 [default = false]; + inline bool has_delivery_required() const; + inline void clear_delivery_required(); + static const int kDeliveryRequiredFieldNumber = 3; + inline bool delivery_required() const; + inline void set_delivery_required(bool value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.notification.v1.Subscription) + private: + inline void set_has_subscriber(); + inline void clear_has_subscriber(); + inline void set_has_delivery_required(); + inline void clear_has_delivery_required(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::notification::v1::Target > target_; + ::bgs::protocol::account::v1::Identity* subscriber_; + bool delivery_required_; + friend void TC_SHARED_API protobuf_AddDesc_notification_5ftypes_2eproto(); + friend void protobuf_AssignDesc_notification_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_notification_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static Subscription* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API Notification : public ::google::protobuf::Message { + public: + Notification(); + virtual ~Notification(); + + Notification(const Notification& from); + + inline Notification& operator=(const Notification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Notification& default_instance(); + + void Swap(Notification* other); + + // implements Message ---------------------------------------------- + + Notification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Notification& from); + void MergeFrom(const Notification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId sender_id = 1; + inline bool has_sender_id() const; + inline void clear_sender_id(); + static const int kSenderIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& sender_id() const; + inline ::bgs::protocol::EntityId* mutable_sender_id(); + inline ::bgs::protocol::EntityId* release_sender_id(); + inline void set_allocated_sender_id(::bgs::protocol::EntityId* sender_id); + + // required .bgs.protocol.EntityId target_id = 2; + inline bool has_target_id() const; + inline void clear_target_id(); + static const int kTargetIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& target_id() const; + inline ::bgs::protocol::EntityId* mutable_target_id(); + inline ::bgs::protocol::EntityId* release_target_id(); + inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id); + + // required string type = 3; + inline bool has_type() const; + inline void clear_type(); + static const int kTypeFieldNumber = 3; + inline const ::std::string& type() const; + inline void set_type(const ::std::string& value); + inline void set_type(const char* value); + inline void set_type(const char* value, size_t size); + inline ::std::string* mutable_type(); + inline ::std::string* release_type(); + inline void set_allocated_type(::std::string* type); + + // repeated .bgs.protocol.Attribute attribute = 4; + inline int attribute_size() const; + inline void clear_attribute(); + static const int kAttributeFieldNumber = 4; + inline const ::bgs::protocol::Attribute& attribute(int index) const; + inline ::bgs::protocol::Attribute* mutable_attribute(int index); + inline ::bgs::protocol::Attribute* add_attribute(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& + attribute() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* + mutable_attribute(); + + // optional .bgs.protocol.EntityId sender_account_id = 5; + inline bool has_sender_account_id() const; + inline void clear_sender_account_id(); + static const int kSenderAccountIdFieldNumber = 5; + inline const ::bgs::protocol::EntityId& sender_account_id() const; + inline ::bgs::protocol::EntityId* mutable_sender_account_id(); + inline ::bgs::protocol::EntityId* release_sender_account_id(); + inline void set_allocated_sender_account_id(::bgs::protocol::EntityId* sender_account_id); + + // optional .bgs.protocol.EntityId target_account_id = 6; + inline bool has_target_account_id() const; + inline void clear_target_account_id(); + static const int kTargetAccountIdFieldNumber = 6; + inline const ::bgs::protocol::EntityId& target_account_id() const; + inline ::bgs::protocol::EntityId* mutable_target_account_id(); + inline ::bgs::protocol::EntityId* release_target_account_id(); + inline void set_allocated_target_account_id(::bgs::protocol::EntityId* target_account_id); + + // optional string sender_battle_tag = 7; + inline bool has_sender_battle_tag() const; + inline void clear_sender_battle_tag(); + static const int kSenderBattleTagFieldNumber = 7; + inline const ::std::string& sender_battle_tag() const; + inline void set_sender_battle_tag(const ::std::string& value); + inline void set_sender_battle_tag(const char* value); + inline void set_sender_battle_tag(const char* value, size_t size); + inline ::std::string* mutable_sender_battle_tag(); + inline ::std::string* release_sender_battle_tag(); + inline void set_allocated_sender_battle_tag(::std::string* sender_battle_tag); + + // optional string target_battle_tag = 8; + inline bool has_target_battle_tag() const; + inline void clear_target_battle_tag(); + static const int kTargetBattleTagFieldNumber = 8; + inline const ::std::string& target_battle_tag() const; + inline void set_target_battle_tag(const ::std::string& value); + inline void set_target_battle_tag(const char* value); + inline void set_target_battle_tag(const char* value, size_t size); + inline ::std::string* mutable_target_battle_tag(); + inline ::std::string* release_target_battle_tag(); + inline void set_allocated_target_battle_tag(::std::string* target_battle_tag); + + // optional .bgs.protocol.ProcessId peer = 9; + inline bool has_peer() const; + inline void clear_peer(); + static const int kPeerFieldNumber = 9; + inline const ::bgs::protocol::ProcessId& peer() const; + inline ::bgs::protocol::ProcessId* mutable_peer(); + inline ::bgs::protocol::ProcessId* release_peer(); + inline void set_allocated_peer(::bgs::protocol::ProcessId* peer); + + // optional .bgs.protocol.account.v1.Identity forwarding_identity = 10; + inline bool has_forwarding_identity() const; + inline void clear_forwarding_identity(); + static const int kForwardingIdentityFieldNumber = 10; + inline const ::bgs::protocol::account::v1::Identity& forwarding_identity() const; + inline ::bgs::protocol::account::v1::Identity* mutable_forwarding_identity(); + inline ::bgs::protocol::account::v1::Identity* release_forwarding_identity(); + inline void set_allocated_forwarding_identity(::bgs::protocol::account::v1::Identity* forwarding_identity); + + // @@protoc_insertion_point(class_scope:bgs.protocol.notification.v1.Notification) + private: + inline void set_has_sender_id(); + inline void clear_has_sender_id(); + inline void set_has_target_id(); + inline void clear_has_target_id(); + inline void set_has_type(); + inline void clear_has_type(); + inline void set_has_sender_account_id(); + inline void clear_has_sender_account_id(); + inline void set_has_target_account_id(); + inline void clear_has_target_account_id(); + inline void set_has_sender_battle_tag(); + inline void clear_has_sender_battle_tag(); + inline void set_has_target_battle_tag(); + inline void clear_has_target_battle_tag(); + inline void set_has_peer(); + inline void clear_has_peer(); + inline void set_has_forwarding_identity(); + inline void clear_has_forwarding_identity(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* sender_id_; + ::bgs::protocol::EntityId* target_id_; + ::std::string* type_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_; + ::bgs::protocol::EntityId* sender_account_id_; + ::bgs::protocol::EntityId* target_account_id_; + ::std::string* sender_battle_tag_; + ::std::string* target_battle_tag_; + ::bgs::protocol::ProcessId* peer_; + ::bgs::protocol::account::v1::Identity* forwarding_identity_; + friend void TC_SHARED_API protobuf_AddDesc_notification_5ftypes_2eproto(); + friend void protobuf_AssignDesc_notification_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_notification_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static Notification* default_instance_; +}; +// =================================================================== + + +// =================================================================== + + +// =================================================================== + +// Target + +// optional .bgs.protocol.account.v1.Identity identity = 1; +inline bool Target::has_identity() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Target::set_has_identity() { + _has_bits_[0] |= 0x00000001u; +} +inline void Target::clear_has_identity() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Target::clear_identity() { + if (identity_ != NULL) identity_->::bgs::protocol::account::v1::Identity::Clear(); + clear_has_identity(); +} +inline const ::bgs::protocol::account::v1::Identity& Target::identity() const { + // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Target.identity) + return identity_ != NULL ? *identity_ : *default_instance_->identity_; +} +inline ::bgs::protocol::account::v1::Identity* Target::mutable_identity() { + set_has_identity(); + if (identity_ == NULL) identity_ = new ::bgs::protocol::account::v1::Identity; + // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Target.identity) + return identity_; +} +inline ::bgs::protocol::account::v1::Identity* Target::release_identity() { + clear_has_identity(); + ::bgs::protocol::account::v1::Identity* temp = identity_; + identity_ = NULL; + return temp; +} +inline void Target::set_allocated_identity(::bgs::protocol::account::v1::Identity* identity) { + delete identity_; + identity_ = identity; + if (identity) { + set_has_identity(); + } else { + clear_has_identity(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.notification.v1.Target.identity) +} + +// optional string type = 2; +inline bool Target::has_type() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Target::set_has_type() { + _has_bits_[0] |= 0x00000002u; +} +inline void Target::clear_has_type() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Target::clear_type() { + if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + type_->clear(); + } + clear_has_type(); +} +inline const ::std::string& Target::type() const { + // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Target.type) + return *type_; +} +inline void Target::set_type(const ::std::string& value) { + set_has_type(); + if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + type_ = new ::std::string; + } + type_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.notification.v1.Target.type) +} +inline void Target::set_type(const char* value) { + set_has_type(); + if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + type_ = new ::std::string; + } + type_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.notification.v1.Target.type) +} +inline void Target::set_type(const char* value, size_t size) { + set_has_type(); + if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + type_ = new ::std::string; + } + type_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.notification.v1.Target.type) +} +inline ::std::string* Target::mutable_type() { + set_has_type(); + if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + type_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Target.type) + return type_; +} +inline ::std::string* Target::release_type() { + clear_has_type(); + if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = type_; + type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void Target::set_allocated_type(::std::string* type) { + if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete type_; + } + if (type) { + set_has_type(); + type_ = type; + } else { + clear_has_type(); + type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.notification.v1.Target.type) +} + +// ------------------------------------------------------------------- + +// Subscription + +// repeated .bgs.protocol.notification.v1.Target target = 1; +inline int Subscription::target_size() const { + return target_.size(); +} +inline void Subscription::clear_target() { + target_.Clear(); +} +inline const ::bgs::protocol::notification::v1::Target& Subscription::target(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Subscription.target) + return target_.Get(index); +} +inline ::bgs::protocol::notification::v1::Target* Subscription::mutable_target(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Subscription.target) + return target_.Mutable(index); +} +inline ::bgs::protocol::notification::v1::Target* Subscription::add_target() { + // @@protoc_insertion_point(field_add:bgs.protocol.notification.v1.Subscription.target) + return target_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::notification::v1::Target >& +Subscription::target() const { + // @@protoc_insertion_point(field_list:bgs.protocol.notification.v1.Subscription.target) + return target_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::notification::v1::Target >* +Subscription::mutable_target() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.notification.v1.Subscription.target) + return &target_; +} + +// optional .bgs.protocol.account.v1.Identity subscriber = 2; +inline bool Subscription::has_subscriber() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Subscription::set_has_subscriber() { + _has_bits_[0] |= 0x00000002u; +} +inline void Subscription::clear_has_subscriber() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Subscription::clear_subscriber() { + if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear(); + clear_has_subscriber(); +} +inline const ::bgs::protocol::account::v1::Identity& Subscription::subscriber() const { + // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Subscription.subscriber) + return subscriber_ != NULL ? *subscriber_ : *default_instance_->subscriber_; +} +inline ::bgs::protocol::account::v1::Identity* Subscription::mutable_subscriber() { + set_has_subscriber(); + if (subscriber_ == NULL) subscriber_ = new ::bgs::protocol::account::v1::Identity; + // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Subscription.subscriber) + return subscriber_; +} +inline ::bgs::protocol::account::v1::Identity* Subscription::release_subscriber() { + clear_has_subscriber(); + ::bgs::protocol::account::v1::Identity* temp = subscriber_; + subscriber_ = NULL; + return temp; +} +inline void Subscription::set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber) { + delete subscriber_; + subscriber_ = subscriber; + if (subscriber) { + set_has_subscriber(); + } else { + clear_has_subscriber(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.notification.v1.Subscription.subscriber) +} + +// optional bool delivery_required = 3 [default = false]; +inline bool Subscription::has_delivery_required() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void Subscription::set_has_delivery_required() { + _has_bits_[0] |= 0x00000004u; +} +inline void Subscription::clear_has_delivery_required() { + _has_bits_[0] &= ~0x00000004u; +} +inline void Subscription::clear_delivery_required() { + delivery_required_ = false; + clear_has_delivery_required(); +} +inline bool Subscription::delivery_required() const { + // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Subscription.delivery_required) + return delivery_required_; +} +inline void Subscription::set_delivery_required(bool value) { + set_has_delivery_required(); + delivery_required_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.notification.v1.Subscription.delivery_required) +} + +// ------------------------------------------------------------------- + +// Notification + +// optional .bgs.protocol.EntityId sender_id = 1; +inline bool Notification::has_sender_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Notification::set_has_sender_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void Notification::clear_has_sender_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Notification::clear_sender_id() { + if (sender_id_ != NULL) sender_id_->::bgs::protocol::EntityId::Clear(); + clear_has_sender_id(); +} +inline const ::bgs::protocol::EntityId& Notification::sender_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Notification.sender_id) + return sender_id_ != NULL ? *sender_id_ : *default_instance_->sender_id_; +} +inline ::bgs::protocol::EntityId* Notification::mutable_sender_id() { + set_has_sender_id(); + if (sender_id_ == NULL) sender_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Notification.sender_id) + return sender_id_; +} +inline ::bgs::protocol::EntityId* Notification::release_sender_id() { + clear_has_sender_id(); + ::bgs::protocol::EntityId* temp = sender_id_; + sender_id_ = NULL; + return temp; +} +inline void Notification::set_allocated_sender_id(::bgs::protocol::EntityId* sender_id) { + delete sender_id_; + sender_id_ = sender_id; + if (sender_id) { + set_has_sender_id(); + } else { + clear_has_sender_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.notification.v1.Notification.sender_id) +} + +// required .bgs.protocol.EntityId target_id = 2; +inline bool Notification::has_target_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Notification::set_has_target_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void Notification::clear_has_target_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Notification::clear_target_id() { + if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear(); + clear_has_target_id(); +} +inline const ::bgs::protocol::EntityId& Notification::target_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Notification.target_id) + return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_; +} +inline ::bgs::protocol::EntityId* Notification::mutable_target_id() { + set_has_target_id(); + if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Notification.target_id) + return target_id_; +} +inline ::bgs::protocol::EntityId* Notification::release_target_id() { + clear_has_target_id(); + ::bgs::protocol::EntityId* temp = target_id_; + target_id_ = NULL; + return temp; +} +inline void Notification::set_allocated_target_id(::bgs::protocol::EntityId* target_id) { + delete target_id_; + target_id_ = target_id; + if (target_id) { + set_has_target_id(); + } else { + clear_has_target_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.notification.v1.Notification.target_id) +} + +// required string type = 3; +inline bool Notification::has_type() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void Notification::set_has_type() { + _has_bits_[0] |= 0x00000004u; +} +inline void Notification::clear_has_type() { + _has_bits_[0] &= ~0x00000004u; +} +inline void Notification::clear_type() { + if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + type_->clear(); + } + clear_has_type(); +} +inline const ::std::string& Notification::type() const { + // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Notification.type) + return *type_; +} +inline void Notification::set_type(const ::std::string& value) { + set_has_type(); + if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + type_ = new ::std::string; + } + type_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.notification.v1.Notification.type) +} +inline void Notification::set_type(const char* value) { + set_has_type(); + if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + type_ = new ::std::string; + } + type_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.notification.v1.Notification.type) +} +inline void Notification::set_type(const char* value, size_t size) { + set_has_type(); + if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + type_ = new ::std::string; + } + type_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.notification.v1.Notification.type) +} +inline ::std::string* Notification::mutable_type() { + set_has_type(); + if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + type_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Notification.type) + return type_; +} +inline ::std::string* Notification::release_type() { + clear_has_type(); + if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = type_; + type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void Notification::set_allocated_type(::std::string* type) { + if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete type_; + } + if (type) { + set_has_type(); + type_ = type; + } else { + clear_has_type(); + type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.notification.v1.Notification.type) +} + +// repeated .bgs.protocol.Attribute attribute = 4; +inline int Notification::attribute_size() const { + return attribute_.size(); +} +inline void Notification::clear_attribute() { + attribute_.Clear(); +} +inline const ::bgs::protocol::Attribute& Notification::attribute(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Notification.attribute) + return attribute_.Get(index); +} +inline ::bgs::protocol::Attribute* Notification::mutable_attribute(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Notification.attribute) + return attribute_.Mutable(index); +} +inline ::bgs::protocol::Attribute* Notification::add_attribute() { + // @@protoc_insertion_point(field_add:bgs.protocol.notification.v1.Notification.attribute) + return attribute_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& +Notification::attribute() const { + // @@protoc_insertion_point(field_list:bgs.protocol.notification.v1.Notification.attribute) + return attribute_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* +Notification::mutable_attribute() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.notification.v1.Notification.attribute) + return &attribute_; +} + +// optional .bgs.protocol.EntityId sender_account_id = 5; +inline bool Notification::has_sender_account_id() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void Notification::set_has_sender_account_id() { + _has_bits_[0] |= 0x00000010u; +} +inline void Notification::clear_has_sender_account_id() { + _has_bits_[0] &= ~0x00000010u; +} +inline void Notification::clear_sender_account_id() { + if (sender_account_id_ != NULL) sender_account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_sender_account_id(); +} +inline const ::bgs::protocol::EntityId& Notification::sender_account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Notification.sender_account_id) + return sender_account_id_ != NULL ? *sender_account_id_ : *default_instance_->sender_account_id_; +} +inline ::bgs::protocol::EntityId* Notification::mutable_sender_account_id() { + set_has_sender_account_id(); + if (sender_account_id_ == NULL) sender_account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Notification.sender_account_id) + return sender_account_id_; +} +inline ::bgs::protocol::EntityId* Notification::release_sender_account_id() { + clear_has_sender_account_id(); + ::bgs::protocol::EntityId* temp = sender_account_id_; + sender_account_id_ = NULL; + return temp; +} +inline void Notification::set_allocated_sender_account_id(::bgs::protocol::EntityId* sender_account_id) { + delete sender_account_id_; + sender_account_id_ = sender_account_id; + if (sender_account_id) { + set_has_sender_account_id(); + } else { + clear_has_sender_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.notification.v1.Notification.sender_account_id) +} + +// optional .bgs.protocol.EntityId target_account_id = 6; +inline bool Notification::has_target_account_id() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void Notification::set_has_target_account_id() { + _has_bits_[0] |= 0x00000020u; +} +inline void Notification::clear_has_target_account_id() { + _has_bits_[0] &= ~0x00000020u; +} +inline void Notification::clear_target_account_id() { + if (target_account_id_ != NULL) target_account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_target_account_id(); +} +inline const ::bgs::protocol::EntityId& Notification::target_account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Notification.target_account_id) + return target_account_id_ != NULL ? *target_account_id_ : *default_instance_->target_account_id_; +} +inline ::bgs::protocol::EntityId* Notification::mutable_target_account_id() { + set_has_target_account_id(); + if (target_account_id_ == NULL) target_account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Notification.target_account_id) + return target_account_id_; +} +inline ::bgs::protocol::EntityId* Notification::release_target_account_id() { + clear_has_target_account_id(); + ::bgs::protocol::EntityId* temp = target_account_id_; + target_account_id_ = NULL; + return temp; +} +inline void Notification::set_allocated_target_account_id(::bgs::protocol::EntityId* target_account_id) { + delete target_account_id_; + target_account_id_ = target_account_id; + if (target_account_id) { + set_has_target_account_id(); + } else { + clear_has_target_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.notification.v1.Notification.target_account_id) +} + +// optional string sender_battle_tag = 7; +inline bool Notification::has_sender_battle_tag() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void Notification::set_has_sender_battle_tag() { + _has_bits_[0] |= 0x00000040u; +} +inline void Notification::clear_has_sender_battle_tag() { + _has_bits_[0] &= ~0x00000040u; +} +inline void Notification::clear_sender_battle_tag() { + if (sender_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sender_battle_tag_->clear(); + } + clear_has_sender_battle_tag(); +} +inline const ::std::string& Notification::sender_battle_tag() const { + // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Notification.sender_battle_tag) + return *sender_battle_tag_; +} +inline void Notification::set_sender_battle_tag(const ::std::string& value) { + set_has_sender_battle_tag(); + if (sender_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sender_battle_tag_ = new ::std::string; + } + sender_battle_tag_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.notification.v1.Notification.sender_battle_tag) +} +inline void Notification::set_sender_battle_tag(const char* value) { + set_has_sender_battle_tag(); + if (sender_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sender_battle_tag_ = new ::std::string; + } + sender_battle_tag_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.notification.v1.Notification.sender_battle_tag) +} +inline void Notification::set_sender_battle_tag(const char* value, size_t size) { + set_has_sender_battle_tag(); + if (sender_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sender_battle_tag_ = new ::std::string; + } + sender_battle_tag_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.notification.v1.Notification.sender_battle_tag) +} +inline ::std::string* Notification::mutable_sender_battle_tag() { + set_has_sender_battle_tag(); + if (sender_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + sender_battle_tag_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Notification.sender_battle_tag) + return sender_battle_tag_; +} +inline ::std::string* Notification::release_sender_battle_tag() { + clear_has_sender_battle_tag(); + if (sender_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = sender_battle_tag_; + sender_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void Notification::set_allocated_sender_battle_tag(::std::string* sender_battle_tag) { + if (sender_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete sender_battle_tag_; + } + if (sender_battle_tag) { + set_has_sender_battle_tag(); + sender_battle_tag_ = sender_battle_tag; + } else { + clear_has_sender_battle_tag(); + sender_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.notification.v1.Notification.sender_battle_tag) +} + +// optional string target_battle_tag = 8; +inline bool Notification::has_target_battle_tag() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void Notification::set_has_target_battle_tag() { + _has_bits_[0] |= 0x00000080u; +} +inline void Notification::clear_has_target_battle_tag() { + _has_bits_[0] &= ~0x00000080u; +} +inline void Notification::clear_target_battle_tag() { + if (target_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + target_battle_tag_->clear(); + } + clear_has_target_battle_tag(); +} +inline const ::std::string& Notification::target_battle_tag() const { + // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Notification.target_battle_tag) + return *target_battle_tag_; +} +inline void Notification::set_target_battle_tag(const ::std::string& value) { + set_has_target_battle_tag(); + if (target_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + target_battle_tag_ = new ::std::string; + } + target_battle_tag_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.notification.v1.Notification.target_battle_tag) +} +inline void Notification::set_target_battle_tag(const char* value) { + set_has_target_battle_tag(); + if (target_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + target_battle_tag_ = new ::std::string; + } + target_battle_tag_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.notification.v1.Notification.target_battle_tag) +} +inline void Notification::set_target_battle_tag(const char* value, size_t size) { + set_has_target_battle_tag(); + if (target_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + target_battle_tag_ = new ::std::string; + } + target_battle_tag_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.notification.v1.Notification.target_battle_tag) +} +inline ::std::string* Notification::mutable_target_battle_tag() { + set_has_target_battle_tag(); + if (target_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + target_battle_tag_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Notification.target_battle_tag) + return target_battle_tag_; +} +inline ::std::string* Notification::release_target_battle_tag() { + clear_has_target_battle_tag(); + if (target_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = target_battle_tag_; + target_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void Notification::set_allocated_target_battle_tag(::std::string* target_battle_tag) { + if (target_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete target_battle_tag_; + } + if (target_battle_tag) { + set_has_target_battle_tag(); + target_battle_tag_ = target_battle_tag; + } else { + clear_has_target_battle_tag(); + target_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.notification.v1.Notification.target_battle_tag) +} + +// optional .bgs.protocol.ProcessId peer = 9; +inline bool Notification::has_peer() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void Notification::set_has_peer() { + _has_bits_[0] |= 0x00000100u; +} +inline void Notification::clear_has_peer() { + _has_bits_[0] &= ~0x00000100u; +} +inline void Notification::clear_peer() { + if (peer_ != NULL) peer_->::bgs::protocol::ProcessId::Clear(); + clear_has_peer(); +} +inline const ::bgs::protocol::ProcessId& Notification::peer() const { + // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Notification.peer) + return peer_ != NULL ? *peer_ : *default_instance_->peer_; +} +inline ::bgs::protocol::ProcessId* Notification::mutable_peer() { + set_has_peer(); + if (peer_ == NULL) peer_ = new ::bgs::protocol::ProcessId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Notification.peer) + return peer_; +} +inline ::bgs::protocol::ProcessId* Notification::release_peer() { + clear_has_peer(); + ::bgs::protocol::ProcessId* temp = peer_; + peer_ = NULL; + return temp; +} +inline void Notification::set_allocated_peer(::bgs::protocol::ProcessId* peer) { + delete peer_; + peer_ = peer; + if (peer) { + set_has_peer(); + } else { + clear_has_peer(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.notification.v1.Notification.peer) +} + +// optional .bgs.protocol.account.v1.Identity forwarding_identity = 10; +inline bool Notification::has_forwarding_identity() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +inline void Notification::set_has_forwarding_identity() { + _has_bits_[0] |= 0x00000200u; +} +inline void Notification::clear_has_forwarding_identity() { + _has_bits_[0] &= ~0x00000200u; +} +inline void Notification::clear_forwarding_identity() { + if (forwarding_identity_ != NULL) forwarding_identity_->::bgs::protocol::account::v1::Identity::Clear(); + clear_has_forwarding_identity(); +} +inline const ::bgs::protocol::account::v1::Identity& Notification::forwarding_identity() const { + // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Notification.forwarding_identity) + return forwarding_identity_ != NULL ? *forwarding_identity_ : *default_instance_->forwarding_identity_; +} +inline ::bgs::protocol::account::v1::Identity* Notification::mutable_forwarding_identity() { + set_has_forwarding_identity(); + if (forwarding_identity_ == NULL) forwarding_identity_ = new ::bgs::protocol::account::v1::Identity; + // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Notification.forwarding_identity) + return forwarding_identity_; +} +inline ::bgs::protocol::account::v1::Identity* Notification::release_forwarding_identity() { + clear_has_forwarding_identity(); + ::bgs::protocol::account::v1::Identity* temp = forwarding_identity_; + forwarding_identity_ = NULL; + return temp; +} +inline void Notification::set_allocated_forwarding_identity(::bgs::protocol::account::v1::Identity* forwarding_identity) { + delete forwarding_identity_; + forwarding_identity_ = forwarding_identity; + if (forwarding_identity) { + set_has_forwarding_identity(); + } else { + clear_has_forwarding_identity(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.notification.v1.Notification.forwarding_identity) +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace notification +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_notification_5ftypes_2eproto__INCLUDED diff --git a/src/server/proto/Client/presence_service.pb.cc b/src/server/proto/Client/presence_service.pb.cc new file mode 100644 index 00000000000..3d2cc3f8437 --- /dev/null +++ b/src/server/proto/Client/presence_service.pb.cc @@ -0,0 +1,2651 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: presence_service.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "presence_service.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +#include "BattlenetRpcErrorCodes.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { +namespace presence { +namespace v1 { + +namespace { + +const ::google::protobuf::Descriptor* SubscribeRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SubscribeRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* SubscribeNotificationRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SubscribeNotificationRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* UnsubscribeRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + UnsubscribeRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* UpdateRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + UpdateRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* QueryRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + QueryRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* QueryResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + QueryResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* OwnershipRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + OwnershipRequest_reflection_ = NULL; +const ::google::protobuf::ServiceDescriptor* PresenceService_descriptor_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_presence_5fservice_2eproto() { + protobuf_AddDesc_presence_5fservice_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "presence_service.proto"); + GOOGLE_CHECK(file != NULL); + SubscribeRequest_descriptor_ = file->message_type(0); + static const int SubscribeRequest_offsets_[5] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, entity_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, object_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, program_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, flag_public_), + }; + SubscribeRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + SubscribeRequest_descriptor_, + SubscribeRequest::default_instance_, + SubscribeRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(SubscribeRequest)); + SubscribeNotificationRequest_descriptor_ = file->message_type(1); + static const int SubscribeNotificationRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeNotificationRequest, entity_id_), + }; + SubscribeNotificationRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + SubscribeNotificationRequest_descriptor_, + SubscribeNotificationRequest::default_instance_, + SubscribeNotificationRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeNotificationRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeNotificationRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(SubscribeNotificationRequest)); + UnsubscribeRequest_descriptor_ = file->message_type(2); + static const int UnsubscribeRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, entity_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, object_id_), + }; + UnsubscribeRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + UnsubscribeRequest_descriptor_, + UnsubscribeRequest::default_instance_, + UnsubscribeRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(UnsubscribeRequest)); + UpdateRequest_descriptor_ = file->message_type(3); + static const int UpdateRequest_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateRequest, entity_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateRequest, field_operation_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateRequest, no_create_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateRequest, agent_id_), + }; + UpdateRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + UpdateRequest_descriptor_, + UpdateRequest::default_instance_, + UpdateRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(UpdateRequest)); + QueryRequest_descriptor_ = file->message_type(4); + static const int QueryRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryRequest, entity_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryRequest, key_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryRequest, agent_id_), + }; + QueryRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + QueryRequest_descriptor_, + QueryRequest::default_instance_, + QueryRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(QueryRequest)); + QueryResponse_descriptor_ = file->message_type(5); + static const int QueryResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryResponse, field_), + }; + QueryResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + QueryResponse_descriptor_, + QueryResponse::default_instance_, + QueryResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(QueryResponse)); + OwnershipRequest_descriptor_ = file->message_type(6); + static const int OwnershipRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OwnershipRequest, entity_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OwnershipRequest, release_ownership_), + }; + OwnershipRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + OwnershipRequest_descriptor_, + OwnershipRequest::default_instance_, + OwnershipRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OwnershipRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OwnershipRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(OwnershipRequest)); + PresenceService_descriptor_ = file->service(0); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_presence_5fservice_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SubscribeRequest_descriptor_, &SubscribeRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SubscribeNotificationRequest_descriptor_, &SubscribeNotificationRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + UnsubscribeRequest_descriptor_, &UnsubscribeRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + UpdateRequest_descriptor_, &UpdateRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + QueryRequest_descriptor_, &QueryRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + QueryResponse_descriptor_, &QueryResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + OwnershipRequest_descriptor_, &OwnershipRequest::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_presence_5fservice_2eproto() { + delete SubscribeRequest::default_instance_; + delete SubscribeRequest_reflection_; + delete SubscribeNotificationRequest::default_instance_; + delete SubscribeNotificationRequest_reflection_; + delete UnsubscribeRequest::default_instance_; + delete UnsubscribeRequest_reflection_; + delete UpdateRequest::default_instance_; + delete UpdateRequest_reflection_; + delete QueryRequest::default_instance_; + delete QueryRequest_reflection_; + delete QueryResponse::default_instance_; + delete QueryResponse_reflection_; + delete OwnershipRequest::default_instance_; + delete OwnershipRequest_reflection_; +} + +void protobuf_AddDesc_presence_5fservice_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto(); + ::bgs::protocol::presence::v1::protobuf_AddDesc_presence_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\026presence_service.proto\022\030bgs.protocol.p" + "resence.v1\032\022entity_types.proto\032\024presence" + "_types.proto\032\017rpc_types.proto\"\252\001\n\020Subscr" + "ibeRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.proto" + "col.EntityId\022)\n\tentity_id\030\002 \002(\0132\026.bgs.pr" + "otocol.EntityId\022\021\n\tobject_id\030\003 \002(\004\022\017\n\007pr" + "ogram\030\004 \003(\007\022\035\n\013flag_public\030\005 \001(\010:\004trueB\002" + "\030\001\"I\n\034SubscribeNotificationRequest\022)\n\ten" + "tity_id\030\001 \002(\0132\026.bgs.protocol.EntityId\"|\n" + "\022UnsubscribeRequest\022(\n\010agent_id\030\001 \001(\0132\026." + "bgs.protocol.EntityId\022)\n\tentity_id\030\002 \002(\013" + "2\026.bgs.protocol.EntityId\022\021\n\tobject_id\030\003 " + "\001(\004\"\301\001\n\rUpdateRequest\022)\n\tentity_id\030\001 \002(\013" + "2\026.bgs.protocol.EntityId\022A\n\017field_operat" + "ion\030\002 \003(\0132(.bgs.protocol.presence.v1.Fie" + "ldOperation\022\030\n\tno_create\030\003 \001(\010:\005false\022(\n" + "\010agent_id\030\004 \001(\0132\026.bgs.protocol.EntityId\"" + "\224\001\n\014QueryRequest\022)\n\tentity_id\030\001 \002(\0132\026.bg" + "s.protocol.EntityId\022/\n\003key\030\002 \003(\0132\".bgs.p" + "rotocol.presence.v1.FieldKey\022(\n\010agent_id" + "\030\003 \001(\0132\026.bgs.protocol.EntityId\"\?\n\rQueryR" + "esponse\022.\n\005field\030\002 \003(\0132\037.bgs.protocol.pr" + "esence.v1.Field\"_\n\020OwnershipRequest\022)\n\te" + "ntity_id\030\001 \002(\0132\026.bgs.protocol.EntityId\022 " + "\n\021release_ownership\030\002 \001(\010:\005false2\333\004\n\017Pre" + "senceService\022S\n\tSubscribe\022*.bgs.protocol" + ".presence.v1.SubscribeRequest\032\024.bgs.prot" + "ocol.NoData\"\004\200\265\030\001\022W\n\013Unsubscribe\022,.bgs.p" + "rotocol.presence.v1.UnsubscribeRequest\032\024" + ".bgs.protocol.NoData\"\004\200\265\030\002\022M\n\006Update\022\'.b" + "gs.protocol.presence.v1.UpdateRequest\032\024." + "bgs.protocol.NoData\"\004\200\265\030\003\022^\n\005Query\022&.bgs" + ".protocol.presence.v1.QueryRequest\032\'.bgs" + ".protocol.presence.v1.QueryResponse\"\004\200\265\030" + "\004\022S\n\tOwnership\022*.bgs.protocol.presence.v" + "1.OwnershipRequest\032\024.bgs.protocol.NoData" + "\"\004\200\265\030\005\022k\n\025SubscribeNotification\0226.bgs.pr" + "otocol.presence.v1.SubscribeNotification" + "Request\032\024.bgs.protocol.NoData\"\004\200\265\030\007\032)\312>&" + "bnet.protocol.presence.PresenceServiceB\005" + "H\001\200\001\000", 1605); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "presence_service.proto", &protobuf_RegisterTypes); + SubscribeRequest::default_instance_ = new SubscribeRequest(); + SubscribeNotificationRequest::default_instance_ = new SubscribeNotificationRequest(); + UnsubscribeRequest::default_instance_ = new UnsubscribeRequest(); + UpdateRequest::default_instance_ = new UpdateRequest(); + QueryRequest::default_instance_ = new QueryRequest(); + QueryResponse::default_instance_ = new QueryResponse(); + OwnershipRequest::default_instance_ = new OwnershipRequest(); + SubscribeRequest::default_instance_->InitAsDefaultInstance(); + SubscribeNotificationRequest::default_instance_->InitAsDefaultInstance(); + UnsubscribeRequest::default_instance_->InitAsDefaultInstance(); + UpdateRequest::default_instance_->InitAsDefaultInstance(); + QueryRequest::default_instance_->InitAsDefaultInstance(); + QueryResponse::default_instance_->InitAsDefaultInstance(); + OwnershipRequest::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_presence_5fservice_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_presence_5fservice_2eproto { + StaticDescriptorInitializer_presence_5fservice_2eproto() { + protobuf_AddDesc_presence_5fservice_2eproto(); + } +} static_descriptor_initializer_presence_5fservice_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int SubscribeRequest::kAgentIdFieldNumber; +const int SubscribeRequest::kEntityIdFieldNumber; +const int SubscribeRequest::kObjectIdFieldNumber; +const int SubscribeRequest::kProgramFieldNumber; +const int SubscribeRequest::kFlagPublicFieldNumber; +#endif // !_MSC_VER + +SubscribeRequest::SubscribeRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.SubscribeRequest) +} + +void SubscribeRequest::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +SubscribeRequest::SubscribeRequest(const SubscribeRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.SubscribeRequest) +} + +void SubscribeRequest::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + entity_id_ = NULL; + object_id_ = GOOGLE_ULONGLONG(0); + flag_public_ = true; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +SubscribeRequest::~SubscribeRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.SubscribeRequest) + SharedDtor(); +} + +void SubscribeRequest::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + delete entity_id_; + } +} + +void SubscribeRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SubscribeRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SubscribeRequest_descriptor_; +} + +const SubscribeRequest& SubscribeRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_presence_5fservice_2eproto(); + return *default_instance_; +} + +SubscribeRequest* SubscribeRequest::default_instance_ = NULL; + +SubscribeRequest* SubscribeRequest::New() const { + return new SubscribeRequest; +} + +void SubscribeRequest::Clear() { + if (_has_bits_[0 / 32] & 23) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_entity_id()) { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + } + object_id_ = GOOGLE_ULONGLONG(0); + flag_public_ = true; + } + program_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool SubscribeRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.SubscribeRequest) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_entity_id; + break; + } + + // required .bgs.protocol.EntityId entity_id = 2; + case 2: { + if (tag == 18) { + parse_entity_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_entity_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_object_id; + break; + } + + // required uint64 object_id = 3; + case 3: { + if (tag == 24) { + parse_object_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &object_id_))); + set_has_object_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(37)) goto parse_program; + break; + } + + // repeated fixed32 program = 4; + case 4: { + if (tag == 37) { + parse_program: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + 1, 37, input, this->mutable_program()))); + } else if (tag == 34) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, this->mutable_program()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(37)) goto parse_program; + if (input->ExpectTag(40)) goto parse_flag_public; + break; + } + + // optional bool flag_public = 5 [default = true, deprecated = true]; + case 5: { + if (tag == 40) { + parse_flag_public: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &flag_public_))); + set_has_flag_public(); + } 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:bgs.protocol.presence.v1.SubscribeRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.SubscribeRequest) + return false; +#undef DO_ +} + +void SubscribeRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.SubscribeRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // required .bgs.protocol.EntityId entity_id = 2; + if (has_entity_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->entity_id(), output); + } + + // required uint64 object_id = 3; + if (has_object_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->object_id(), output); + } + + // repeated fixed32 program = 4; + for (int i = 0; i < this->program_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32( + 4, this->program(i), output); + } + + // optional bool flag_public = 5 [default = true, deprecated = true]; + if (has_flag_public()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->flag_public(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.SubscribeRequest) +} + +::google::protobuf::uint8* SubscribeRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.SubscribeRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // required .bgs.protocol.EntityId entity_id = 2; + if (has_entity_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->entity_id(), target); + } + + // required uint64 object_id = 3; + if (has_object_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->object_id(), target); + } + + // repeated fixed32 program = 4; + for (int i = 0; i < this->program_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteFixed32ToArray(4, this->program(i), target); + } + + // optional bool flag_public = 5 [default = true, deprecated = true]; + if (has_flag_public()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->flag_public(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.SubscribeRequest) + return target; +} + +int SubscribeRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // required .bgs.protocol.EntityId entity_id = 2; + if (has_entity_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->entity_id()); + } + + // required uint64 object_id = 3; + if (has_object_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->object_id()); + } + + // optional bool flag_public = 5 [default = true, deprecated = true]; + if (has_flag_public()) { + total_size += 1 + 1; + } + + } + // repeated fixed32 program = 4; + { + int data_size = 0; + data_size = 4 * this->program_size(); + total_size += 1 * this->program_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 SubscribeRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const SubscribeRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void SubscribeRequest::MergeFrom(const SubscribeRequest& from) { + GOOGLE_CHECK_NE(&from, this); + program_.MergeFrom(from.program_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_entity_id()) { + mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id()); + } + if (from.has_object_id()) { + set_object_id(from.object_id()); + } + if (from.has_flag_public()) { + set_flag_public(from.flag_public()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void SubscribeRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SubscribeRequest::CopyFrom(const SubscribeRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SubscribeRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000006) != 0x00000006) return false; + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + if (has_entity_id()) { + if (!this->entity_id().IsInitialized()) return false; + } + return true; +} + +void SubscribeRequest::Swap(SubscribeRequest* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + std::swap(entity_id_, other->entity_id_); + std::swap(object_id_, other->object_id_); + program_.Swap(&other->program_); + std::swap(flag_public_, other->flag_public_); + 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 SubscribeRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SubscribeRequest_descriptor_; + metadata.reflection = SubscribeRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int SubscribeNotificationRequest::kEntityIdFieldNumber; +#endif // !_MSC_VER + +SubscribeNotificationRequest::SubscribeNotificationRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.SubscribeNotificationRequest) +} + +void SubscribeNotificationRequest::InitAsDefaultInstance() { + entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +SubscribeNotificationRequest::SubscribeNotificationRequest(const SubscribeNotificationRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.SubscribeNotificationRequest) +} + +void SubscribeNotificationRequest::SharedCtor() { + _cached_size_ = 0; + entity_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +SubscribeNotificationRequest::~SubscribeNotificationRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.SubscribeNotificationRequest) + SharedDtor(); +} + +void SubscribeNotificationRequest::SharedDtor() { + if (this != default_instance_) { + delete entity_id_; + } +} + +void SubscribeNotificationRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SubscribeNotificationRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SubscribeNotificationRequest_descriptor_; +} + +const SubscribeNotificationRequest& SubscribeNotificationRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_presence_5fservice_2eproto(); + return *default_instance_; +} + +SubscribeNotificationRequest* SubscribeNotificationRequest::default_instance_ = NULL; + +SubscribeNotificationRequest* SubscribeNotificationRequest::New() const { + return new SubscribeNotificationRequest; +} + +void SubscribeNotificationRequest::Clear() { + if (has_entity_id()) { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool SubscribeNotificationRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.SubscribeNotificationRequest) + 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)) { + // required .bgs.protocol.EntityId entity_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_entity_id())); + } 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:bgs.protocol.presence.v1.SubscribeNotificationRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.SubscribeNotificationRequest) + return false; +#undef DO_ +} + +void SubscribeNotificationRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.SubscribeNotificationRequest) + // required .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->entity_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.SubscribeNotificationRequest) +} + +::google::protobuf::uint8* SubscribeNotificationRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.SubscribeNotificationRequest) + // required .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->entity_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.SubscribeNotificationRequest) + return target; +} + +int SubscribeNotificationRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->entity_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void SubscribeNotificationRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const SubscribeNotificationRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void SubscribeNotificationRequest::MergeFrom(const SubscribeNotificationRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_entity_id()) { + mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void SubscribeNotificationRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SubscribeNotificationRequest::CopyFrom(const SubscribeNotificationRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SubscribeNotificationRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_entity_id()) { + if (!this->entity_id().IsInitialized()) return false; + } + return true; +} + +void SubscribeNotificationRequest::Swap(SubscribeNotificationRequest* other) { + if (other != this) { + std::swap(entity_id_, other->entity_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata SubscribeNotificationRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SubscribeNotificationRequest_descriptor_; + metadata.reflection = SubscribeNotificationRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int UnsubscribeRequest::kAgentIdFieldNumber; +const int UnsubscribeRequest::kEntityIdFieldNumber; +const int UnsubscribeRequest::kObjectIdFieldNumber; +#endif // !_MSC_VER + +UnsubscribeRequest::UnsubscribeRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.UnsubscribeRequest) +} + +void UnsubscribeRequest::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +UnsubscribeRequest::UnsubscribeRequest(const UnsubscribeRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.UnsubscribeRequest) +} + +void UnsubscribeRequest::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + entity_id_ = NULL; + object_id_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +UnsubscribeRequest::~UnsubscribeRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.UnsubscribeRequest) + SharedDtor(); +} + +void UnsubscribeRequest::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + delete entity_id_; + } +} + +void UnsubscribeRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* UnsubscribeRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return UnsubscribeRequest_descriptor_; +} + +const UnsubscribeRequest& UnsubscribeRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_presence_5fservice_2eproto(); + return *default_instance_; +} + +UnsubscribeRequest* UnsubscribeRequest::default_instance_ = NULL; + +UnsubscribeRequest* UnsubscribeRequest::New() const { + return new UnsubscribeRequest; +} + +void UnsubscribeRequest::Clear() { + if (_has_bits_[0 / 32] & 7) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_entity_id()) { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + } + object_id_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool UnsubscribeRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.UnsubscribeRequest) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_entity_id; + break; + } + + // required .bgs.protocol.EntityId entity_id = 2; + case 2: { + if (tag == 18) { + parse_entity_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_entity_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_object_id; + break; + } + + // optional uint64 object_id = 3; + case 3: { + if (tag == 24) { + parse_object_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &object_id_))); + set_has_object_id(); + } 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:bgs.protocol.presence.v1.UnsubscribeRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.UnsubscribeRequest) + return false; +#undef DO_ +} + +void UnsubscribeRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.UnsubscribeRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // required .bgs.protocol.EntityId entity_id = 2; + if (has_entity_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->entity_id(), output); + } + + // optional uint64 object_id = 3; + if (has_object_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->object_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.UnsubscribeRequest) +} + +::google::protobuf::uint8* UnsubscribeRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.UnsubscribeRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // required .bgs.protocol.EntityId entity_id = 2; + if (has_entity_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->entity_id(), target); + } + + // optional uint64 object_id = 3; + if (has_object_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->object_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.UnsubscribeRequest) + return target; +} + +int UnsubscribeRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // required .bgs.protocol.EntityId entity_id = 2; + if (has_entity_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->entity_id()); + } + + // optional uint64 object_id = 3; + if (has_object_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->object_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void UnsubscribeRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const UnsubscribeRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void UnsubscribeRequest::MergeFrom(const UnsubscribeRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_entity_id()) { + mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id()); + } + if (from.has_object_id()) { + set_object_id(from.object_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void UnsubscribeRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void UnsubscribeRequest::CopyFrom(const UnsubscribeRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool UnsubscribeRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false; + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + if (has_entity_id()) { + if (!this->entity_id().IsInitialized()) return false; + } + return true; +} + +void UnsubscribeRequest::Swap(UnsubscribeRequest* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + std::swap(entity_id_, other->entity_id_); + std::swap(object_id_, other->object_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata UnsubscribeRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = UnsubscribeRequest_descriptor_; + metadata.reflection = UnsubscribeRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int UpdateRequest::kEntityIdFieldNumber; +const int UpdateRequest::kFieldOperationFieldNumber; +const int UpdateRequest::kNoCreateFieldNumber; +const int UpdateRequest::kAgentIdFieldNumber; +#endif // !_MSC_VER + +UpdateRequest::UpdateRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.UpdateRequest) +} + +void UpdateRequest::InitAsDefaultInstance() { + entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +UpdateRequest::UpdateRequest(const UpdateRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.UpdateRequest) +} + +void UpdateRequest::SharedCtor() { + _cached_size_ = 0; + entity_id_ = NULL; + no_create_ = false; + agent_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +UpdateRequest::~UpdateRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.UpdateRequest) + SharedDtor(); +} + +void UpdateRequest::SharedDtor() { + if (this != default_instance_) { + delete entity_id_; + delete agent_id_; + } +} + +void UpdateRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* UpdateRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return UpdateRequest_descriptor_; +} + +const UpdateRequest& UpdateRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_presence_5fservice_2eproto(); + return *default_instance_; +} + +UpdateRequest* UpdateRequest::default_instance_ = NULL; + +UpdateRequest* UpdateRequest::New() const { + return new UpdateRequest; +} + +void UpdateRequest::Clear() { + if (_has_bits_[0 / 32] & 13) { + if (has_entity_id()) { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + } + no_create_ = false; + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + } + field_operation_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool UpdateRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.UpdateRequest) + 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)) { + // required .bgs.protocol.EntityId entity_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_entity_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_field_operation; + break; + } + + // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2; + case 2: { + if (tag == 18) { + parse_field_operation: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_field_operation())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_field_operation; + if (input->ExpectTag(24)) goto parse_no_create; + break; + } + + // optional bool no_create = 3 [default = false]; + case 3: { + if (tag == 24) { + parse_no_create: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &no_create_))); + set_has_no_create(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_agent_id; + break; + } + + // optional .bgs.protocol.EntityId agent_id = 4; + case 4: { + if (tag == 34) { + parse_agent_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } 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:bgs.protocol.presence.v1.UpdateRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.UpdateRequest) + return false; +#undef DO_ +} + +void UpdateRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.UpdateRequest) + // required .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->entity_id(), output); + } + + // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2; + for (int i = 0; i < this->field_operation_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->field_operation(i), output); + } + + // optional bool no_create = 3 [default = false]; + if (has_no_create()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->no_create(), output); + } + + // optional .bgs.protocol.EntityId agent_id = 4; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->agent_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.UpdateRequest) +} + +::google::protobuf::uint8* UpdateRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.UpdateRequest) + // required .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->entity_id(), target); + } + + // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2; + for (int i = 0; i < this->field_operation_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->field_operation(i), target); + } + + // optional bool no_create = 3 [default = false]; + if (has_no_create()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->no_create(), target); + } + + // optional .bgs.protocol.EntityId agent_id = 4; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->agent_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.UpdateRequest) + return target; +} + +int UpdateRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->entity_id()); + } + + // optional bool no_create = 3 [default = false]; + if (has_no_create()) { + total_size += 1 + 1; + } + + // optional .bgs.protocol.EntityId agent_id = 4; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + } + // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2; + total_size += 1 * this->field_operation_size(); + for (int i = 0; i < this->field_operation_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->field_operation(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 UpdateRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const UpdateRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void UpdateRequest::MergeFrom(const UpdateRequest& from) { + GOOGLE_CHECK_NE(&from, this); + field_operation_.MergeFrom(from.field_operation_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_entity_id()) { + mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id()); + } + if (from.has_no_create()) { + set_no_create(from.no_create()); + } + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void UpdateRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void UpdateRequest::CopyFrom(const UpdateRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool UpdateRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_entity_id()) { + if (!this->entity_id().IsInitialized()) return false; + } + if (!::google::protobuf::internal::AllAreInitialized(this->field_operation())) return false; + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + return true; +} + +void UpdateRequest::Swap(UpdateRequest* other) { + if (other != this) { + std::swap(entity_id_, other->entity_id_); + field_operation_.Swap(&other->field_operation_); + std::swap(no_create_, other->no_create_); + std::swap(agent_id_, other->agent_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata UpdateRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = UpdateRequest_descriptor_; + metadata.reflection = UpdateRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int QueryRequest::kEntityIdFieldNumber; +const int QueryRequest::kKeyFieldNumber; +const int QueryRequest::kAgentIdFieldNumber; +#endif // !_MSC_VER + +QueryRequest::QueryRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.QueryRequest) +} + +void QueryRequest::InitAsDefaultInstance() { + entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +QueryRequest::QueryRequest(const QueryRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.QueryRequest) +} + +void QueryRequest::SharedCtor() { + _cached_size_ = 0; + entity_id_ = NULL; + agent_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +QueryRequest::~QueryRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.QueryRequest) + SharedDtor(); +} + +void QueryRequest::SharedDtor() { + if (this != default_instance_) { + delete entity_id_; + delete agent_id_; + } +} + +void QueryRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* QueryRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return QueryRequest_descriptor_; +} + +const QueryRequest& QueryRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_presence_5fservice_2eproto(); + return *default_instance_; +} + +QueryRequest* QueryRequest::default_instance_ = NULL; + +QueryRequest* QueryRequest::New() const { + return new QueryRequest; +} + +void QueryRequest::Clear() { + if (_has_bits_[0 / 32] & 5) { + if (has_entity_id()) { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + } + key_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool QueryRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.QueryRequest) + 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)) { + // required .bgs.protocol.EntityId entity_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_entity_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_key; + break; + } + + // repeated .bgs.protocol.presence.v1.FieldKey key = 2; + case 2: { + if (tag == 18) { + parse_key: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_key())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_key; + if (input->ExpectTag(26)) goto parse_agent_id; + break; + } + + // optional .bgs.protocol.EntityId agent_id = 3; + case 3: { + if (tag == 26) { + parse_agent_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } 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:bgs.protocol.presence.v1.QueryRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.QueryRequest) + return false; +#undef DO_ +} + +void QueryRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.QueryRequest) + // required .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->entity_id(), output); + } + + // repeated .bgs.protocol.presence.v1.FieldKey key = 2; + for (int i = 0; i < this->key_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->key(i), output); + } + + // optional .bgs.protocol.EntityId agent_id = 3; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->agent_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.QueryRequest) +} + +::google::protobuf::uint8* QueryRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.QueryRequest) + // required .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->entity_id(), target); + } + + // repeated .bgs.protocol.presence.v1.FieldKey key = 2; + for (int i = 0; i < this->key_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->key(i), target); + } + + // optional .bgs.protocol.EntityId agent_id = 3; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->agent_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.QueryRequest) + return target; +} + +int QueryRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->entity_id()); + } + + // optional .bgs.protocol.EntityId agent_id = 3; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + } + // repeated .bgs.protocol.presence.v1.FieldKey key = 2; + total_size += 1 * this->key_size(); + for (int i = 0; i < this->key_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->key(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 QueryRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const QueryRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void QueryRequest::MergeFrom(const QueryRequest& from) { + GOOGLE_CHECK_NE(&from, this); + key_.MergeFrom(from.key_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_entity_id()) { + mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id()); + } + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void QueryRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void QueryRequest::CopyFrom(const QueryRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool QueryRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_entity_id()) { + if (!this->entity_id().IsInitialized()) return false; + } + if (!::google::protobuf::internal::AllAreInitialized(this->key())) return false; + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + return true; +} + +void QueryRequest::Swap(QueryRequest* other) { + if (other != this) { + std::swap(entity_id_, other->entity_id_); + key_.Swap(&other->key_); + std::swap(agent_id_, other->agent_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata QueryRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = QueryRequest_descriptor_; + metadata.reflection = QueryRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int QueryResponse::kFieldFieldNumber; +#endif // !_MSC_VER + +QueryResponse::QueryResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.QueryResponse) +} + +void QueryResponse::InitAsDefaultInstance() { +} + +QueryResponse::QueryResponse(const QueryResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.QueryResponse) +} + +void QueryResponse::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +QueryResponse::~QueryResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.QueryResponse) + SharedDtor(); +} + +void QueryResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void QueryResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* QueryResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return QueryResponse_descriptor_; +} + +const QueryResponse& QueryResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_presence_5fservice_2eproto(); + return *default_instance_; +} + +QueryResponse* QueryResponse::default_instance_ = NULL; + +QueryResponse* QueryResponse::New() const { + return new QueryResponse; +} + +void QueryResponse::Clear() { + field_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool QueryResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.QueryResponse) + 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 .bgs.protocol.presence.v1.Field field = 2; + case 2: { + if (tag == 18) { + parse_field: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_field())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_field; + 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:bgs.protocol.presence.v1.QueryResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.QueryResponse) + return false; +#undef DO_ +} + +void QueryResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.QueryResponse) + // repeated .bgs.protocol.presence.v1.Field field = 2; + for (int i = 0; i < this->field_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->field(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.QueryResponse) +} + +::google::protobuf::uint8* QueryResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.QueryResponse) + // repeated .bgs.protocol.presence.v1.Field field = 2; + for (int i = 0; i < this->field_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->field(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.QueryResponse) + return target; +} + +int QueryResponse::ByteSize() const { + int total_size = 0; + + // repeated .bgs.protocol.presence.v1.Field field = 2; + total_size += 1 * this->field_size(); + for (int i = 0; i < this->field_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->field(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 QueryResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const QueryResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void QueryResponse::MergeFrom(const QueryResponse& from) { + GOOGLE_CHECK_NE(&from, this); + field_.MergeFrom(from.field_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void QueryResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void QueryResponse::CopyFrom(const QueryResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool QueryResponse::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->field())) return false; + return true; +} + +void QueryResponse::Swap(QueryResponse* other) { + if (other != this) { + field_.Swap(&other->field_); + 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 QueryResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = QueryResponse_descriptor_; + metadata.reflection = QueryResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int OwnershipRequest::kEntityIdFieldNumber; +const int OwnershipRequest::kReleaseOwnershipFieldNumber; +#endif // !_MSC_VER + +OwnershipRequest::OwnershipRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.OwnershipRequest) +} + +void OwnershipRequest::InitAsDefaultInstance() { + entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +OwnershipRequest::OwnershipRequest(const OwnershipRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.OwnershipRequest) +} + +void OwnershipRequest::SharedCtor() { + _cached_size_ = 0; + entity_id_ = NULL; + release_ownership_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +OwnershipRequest::~OwnershipRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.OwnershipRequest) + SharedDtor(); +} + +void OwnershipRequest::SharedDtor() { + if (this != default_instance_) { + delete entity_id_; + } +} + +void OwnershipRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* OwnershipRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return OwnershipRequest_descriptor_; +} + +const OwnershipRequest& OwnershipRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_presence_5fservice_2eproto(); + return *default_instance_; +} + +OwnershipRequest* OwnershipRequest::default_instance_ = NULL; + +OwnershipRequest* OwnershipRequest::New() const { + return new OwnershipRequest; +} + +void OwnershipRequest::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_entity_id()) { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + } + release_ownership_ = false; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool OwnershipRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.OwnershipRequest) + 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)) { + // required .bgs.protocol.EntityId entity_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_entity_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_release_ownership; + break; + } + + // optional bool release_ownership = 2 [default = false]; + case 2: { + if (tag == 16) { + parse_release_ownership: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &release_ownership_))); + set_has_release_ownership(); + } 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:bgs.protocol.presence.v1.OwnershipRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.OwnershipRequest) + return false; +#undef DO_ +} + +void OwnershipRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.OwnershipRequest) + // required .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->entity_id(), output); + } + + // optional bool release_ownership = 2 [default = false]; + if (has_release_ownership()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->release_ownership(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.OwnershipRequest) +} + +::google::protobuf::uint8* OwnershipRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.OwnershipRequest) + // required .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->entity_id(), target); + } + + // optional bool release_ownership = 2 [default = false]; + if (has_release_ownership()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->release_ownership(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.OwnershipRequest) + return target; +} + +int OwnershipRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->entity_id()); + } + + // optional bool release_ownership = 2 [default = false]; + if (has_release_ownership()) { + 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 OwnershipRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const OwnershipRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void OwnershipRequest::MergeFrom(const OwnershipRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_entity_id()) { + mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id()); + } + if (from.has_release_ownership()) { + set_release_ownership(from.release_ownership()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void OwnershipRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void OwnershipRequest::CopyFrom(const OwnershipRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool OwnershipRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_entity_id()) { + if (!this->entity_id().IsInitialized()) return false; + } + return true; +} + +void OwnershipRequest::Swap(OwnershipRequest* other) { + if (other != this) { + std::swap(entity_id_, other->entity_id_); + std::swap(release_ownership_, other->release_ownership_); + 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 OwnershipRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = OwnershipRequest_descriptor_; + metadata.reflection = OwnershipRequest_reflection_; + return metadata; +} + + +// =================================================================== + +google::protobuf::ServiceDescriptor const* PresenceService::descriptor() { + protobuf_AssignDescriptorsOnce(); + return PresenceService_descriptor_; +} + +void PresenceService::Subscribe(::bgs::protocol::presence::v1::SubscribeRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method PresenceService.Subscribe(bgs.protocol.presence.v1.SubscribeRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 1, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void PresenceService::Unsubscribe(::bgs::protocol::presence::v1::UnsubscribeRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method PresenceService.Unsubscribe(bgs.protocol.presence.v1.UnsubscribeRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 2, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void PresenceService::Update(::bgs::protocol::presence::v1::UpdateRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method PresenceService.Update(bgs.protocol.presence.v1.UpdateRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 3, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void PresenceService::Query(::bgs::protocol::presence::v1::QueryRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method PresenceService.Query(bgs.protocol.presence.v1.QueryRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 4, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::presence::v1::QueryResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void PresenceService::Ownership(::bgs::protocol::presence::v1::OwnershipRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method PresenceService.Ownership(bgs.protocol.presence.v1.OwnershipRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 5, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void PresenceService::SubscribeNotification(::bgs::protocol::presence::v1::SubscribeNotificationRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method PresenceService.SubscribeNotification(bgs.protocol.presence.v1.SubscribeNotificationRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 7, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void PresenceService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) { + switch(methodId) { + case 1: { + ::bgs::protocol::presence::v1::SubscribeRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for PresenceService.Subscribe server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleSubscribe(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method PresenceService.Subscribe(bgs.protocol.presence.v1.SubscribeRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 1, token, &response); + else + SendResponse(service_hash_, 1, token, status); + break; + } + case 2: { + ::bgs::protocol::presence::v1::UnsubscribeRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for PresenceService.Unsubscribe server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleUnsubscribe(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method PresenceService.Unsubscribe(bgs.protocol.presence.v1.UnsubscribeRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 2, token, &response); + else + SendResponse(service_hash_, 2, token, status); + break; + } + case 3: { + ::bgs::protocol::presence::v1::UpdateRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for PresenceService.Update server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleUpdate(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method PresenceService.Update(bgs.protocol.presence.v1.UpdateRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 3, token, &response); + else + SendResponse(service_hash_, 3, token, status); + break; + } + case 4: { + ::bgs::protocol::presence::v1::QueryRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for PresenceService.Query server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::presence::v1::QueryResponse response; + uint32 status = HandleQuery(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method PresenceService.Query(bgs.protocol.presence.v1.QueryRequest{ %s }) returned bgs.protocol.presence.v1.QueryResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 4, token, &response); + else + SendResponse(service_hash_, 4, token, status); + break; + } + case 5: { + ::bgs::protocol::presence::v1::OwnershipRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for PresenceService.Ownership server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 5, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleOwnership(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method PresenceService.Ownership(bgs.protocol.presence.v1.OwnershipRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 5, token, &response); + else + SendResponse(service_hash_, 5, token, status); + break; + } + case 7: { + ::bgs::protocol::presence::v1::SubscribeNotificationRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for PresenceService.SubscribeNotification server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 7, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleSubscribeNotification(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method PresenceService.SubscribeNotification(bgs.protocol.presence.v1.SubscribeNotificationRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 7, token, &response); + else + SendResponse(service_hash_, 7, token, status); + break; + } + default: + TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId); + SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD); + break; + } +} + +uint32 PresenceService::HandleSubscribe(::bgs::protocol::presence::v1::SubscribeRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method PresenceService.Subscribe({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 PresenceService::HandleUnsubscribe(::bgs::protocol::presence::v1::UnsubscribeRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method PresenceService.Unsubscribe({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 PresenceService::HandleUpdate(::bgs::protocol::presence::v1::UpdateRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method PresenceService.Update({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 PresenceService::HandleQuery(::bgs::protocol::presence::v1::QueryRequest const* request, ::bgs::protocol::presence::v1::QueryResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method PresenceService.Query({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 PresenceService::HandleOwnership(::bgs::protocol::presence::v1::OwnershipRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method PresenceService.Ownership({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 PresenceService::HandleSubscribeNotification(::bgs::protocol::presence::v1::SubscribeNotificationRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method PresenceService.SubscribeNotification({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace presence +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/presence_service.pb.h b/src/server/proto/Client/presence_service.pb.h new file mode 100644 index 00000000000..a9dd7c6678b --- /dev/null +++ b/src/server/proto/Client/presence_service.pb.h @@ -0,0 +1,1499 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: presence_service.proto + +#ifndef PROTOBUF_presence_5fservice_2eproto__INCLUDED +#define PROTOBUF_presence_5fservice_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include "entity_types.pb.h" +#include "presence_types.pb.h" +#include "rpc_types.pb.h" +#include "ServiceBase.h" +#include "MessageBuffer.h" +#include +#include +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { +namespace presence { +namespace v1 { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_presence_5fservice_2eproto(); +void protobuf_AssignDesc_presence_5fservice_2eproto(); +void protobuf_ShutdownFile_presence_5fservice_2eproto(); + +class SubscribeRequest; +class SubscribeNotificationRequest; +class UnsubscribeRequest; +class UpdateRequest; +class QueryRequest; +class QueryResponse; +class OwnershipRequest; + +// =================================================================== + +class TC_SHARED_API SubscribeRequest : public ::google::protobuf::Message { + public: + SubscribeRequest(); + virtual ~SubscribeRequest(); + + SubscribeRequest(const SubscribeRequest& from); + + inline SubscribeRequest& operator=(const SubscribeRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SubscribeRequest& default_instance(); + + void Swap(SubscribeRequest* other); + + // implements Message ---------------------------------------------- + + SubscribeRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SubscribeRequest& from); + void MergeFrom(const SubscribeRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // required .bgs.protocol.EntityId entity_id = 2; + inline bool has_entity_id() const; + inline void clear_entity_id(); + static const int kEntityIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& entity_id() const; + inline ::bgs::protocol::EntityId* mutable_entity_id(); + inline ::bgs::protocol::EntityId* release_entity_id(); + inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id); + + // required uint64 object_id = 3; + inline bool has_object_id() const; + inline void clear_object_id(); + static const int kObjectIdFieldNumber = 3; + inline ::google::protobuf::uint64 object_id() const; + inline void set_object_id(::google::protobuf::uint64 value); + + // repeated fixed32 program = 4; + inline int program_size() const; + inline void clear_program(); + static const int kProgramFieldNumber = 4; + inline ::google::protobuf::uint32 program(int index) const; + inline void set_program(int index, ::google::protobuf::uint32 value); + inline void add_program(::google::protobuf::uint32 value); + inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + program() const; + inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_program(); + + // optional bool flag_public = 5 [default = true, deprecated = true]; + inline bool has_flag_public() const PROTOBUF_DEPRECATED; + inline void clear_flag_public() PROTOBUF_DEPRECATED; + static const int kFlagPublicFieldNumber = 5; + inline bool flag_public() const PROTOBUF_DEPRECATED; + inline void set_flag_public(bool value) PROTOBUF_DEPRECATED; + + // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.SubscribeRequest) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_entity_id(); + inline void clear_has_entity_id(); + inline void set_has_object_id(); + inline void clear_has_object_id(); + inline void set_has_flag_public(); + inline void clear_has_flag_public(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::bgs::protocol::EntityId* entity_id_; + ::google::protobuf::uint64 object_id_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > program_; + bool flag_public_; + friend void TC_SHARED_API protobuf_AddDesc_presence_5fservice_2eproto(); + friend void protobuf_AssignDesc_presence_5fservice_2eproto(); + friend void protobuf_ShutdownFile_presence_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static SubscribeRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API SubscribeNotificationRequest : public ::google::protobuf::Message { + public: + SubscribeNotificationRequest(); + virtual ~SubscribeNotificationRequest(); + + SubscribeNotificationRequest(const SubscribeNotificationRequest& from); + + inline SubscribeNotificationRequest& operator=(const SubscribeNotificationRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SubscribeNotificationRequest& default_instance(); + + void Swap(SubscribeNotificationRequest* other); + + // implements Message ---------------------------------------------- + + SubscribeNotificationRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SubscribeNotificationRequest& from); + void MergeFrom(const SubscribeNotificationRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.EntityId entity_id = 1; + inline bool has_entity_id() const; + inline void clear_entity_id(); + static const int kEntityIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& entity_id() const; + inline ::bgs::protocol::EntityId* mutable_entity_id(); + inline ::bgs::protocol::EntityId* release_entity_id(); + inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id); + + // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.SubscribeNotificationRequest) + private: + inline void set_has_entity_id(); + inline void clear_has_entity_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* entity_id_; + friend void TC_SHARED_API protobuf_AddDesc_presence_5fservice_2eproto(); + friend void protobuf_AssignDesc_presence_5fservice_2eproto(); + friend void protobuf_ShutdownFile_presence_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static SubscribeNotificationRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API UnsubscribeRequest : public ::google::protobuf::Message { + public: + UnsubscribeRequest(); + virtual ~UnsubscribeRequest(); + + UnsubscribeRequest(const UnsubscribeRequest& from); + + inline UnsubscribeRequest& operator=(const UnsubscribeRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const UnsubscribeRequest& default_instance(); + + void Swap(UnsubscribeRequest* other); + + // implements Message ---------------------------------------------- + + UnsubscribeRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const UnsubscribeRequest& from); + void MergeFrom(const UnsubscribeRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // required .bgs.protocol.EntityId entity_id = 2; + inline bool has_entity_id() const; + inline void clear_entity_id(); + static const int kEntityIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& entity_id() const; + inline ::bgs::protocol::EntityId* mutable_entity_id(); + inline ::bgs::protocol::EntityId* release_entity_id(); + inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id); + + // optional uint64 object_id = 3; + inline bool has_object_id() const; + inline void clear_object_id(); + static const int kObjectIdFieldNumber = 3; + inline ::google::protobuf::uint64 object_id() const; + inline void set_object_id(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.UnsubscribeRequest) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_entity_id(); + inline void clear_has_entity_id(); + inline void set_has_object_id(); + inline void clear_has_object_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::bgs::protocol::EntityId* entity_id_; + ::google::protobuf::uint64 object_id_; + friend void TC_SHARED_API protobuf_AddDesc_presence_5fservice_2eproto(); + friend void protobuf_AssignDesc_presence_5fservice_2eproto(); + friend void protobuf_ShutdownFile_presence_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static UnsubscribeRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API UpdateRequest : public ::google::protobuf::Message { + public: + UpdateRequest(); + virtual ~UpdateRequest(); + + UpdateRequest(const UpdateRequest& from); + + inline UpdateRequest& operator=(const UpdateRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const UpdateRequest& default_instance(); + + void Swap(UpdateRequest* other); + + // implements Message ---------------------------------------------- + + UpdateRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const UpdateRequest& from); + void MergeFrom(const UpdateRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.EntityId entity_id = 1; + inline bool has_entity_id() const; + inline void clear_entity_id(); + static const int kEntityIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& entity_id() const; + inline ::bgs::protocol::EntityId* mutable_entity_id(); + inline ::bgs::protocol::EntityId* release_entity_id(); + inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id); + + // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2; + inline int field_operation_size() const; + inline void clear_field_operation(); + static const int kFieldOperationFieldNumber = 2; + inline const ::bgs::protocol::presence::v1::FieldOperation& field_operation(int index) const; + inline ::bgs::protocol::presence::v1::FieldOperation* mutable_field_operation(int index); + inline ::bgs::protocol::presence::v1::FieldOperation* add_field_operation(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation >& + field_operation() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation >* + mutable_field_operation(); + + // optional bool no_create = 3 [default = false]; + inline bool has_no_create() const; + inline void clear_no_create(); + static const int kNoCreateFieldNumber = 3; + inline bool no_create() const; + inline void set_no_create(bool value); + + // optional .bgs.protocol.EntityId agent_id = 4; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 4; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.UpdateRequest) + private: + inline void set_has_entity_id(); + inline void clear_has_entity_id(); + inline void set_has_no_create(); + inline void clear_has_no_create(); + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* entity_id_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation > field_operation_; + ::bgs::protocol::EntityId* agent_id_; + bool no_create_; + friend void TC_SHARED_API protobuf_AddDesc_presence_5fservice_2eproto(); + friend void protobuf_AssignDesc_presence_5fservice_2eproto(); + friend void protobuf_ShutdownFile_presence_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static UpdateRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API QueryRequest : public ::google::protobuf::Message { + public: + QueryRequest(); + virtual ~QueryRequest(); + + QueryRequest(const QueryRequest& from); + + inline QueryRequest& operator=(const QueryRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const QueryRequest& default_instance(); + + void Swap(QueryRequest* other); + + // implements Message ---------------------------------------------- + + QueryRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const QueryRequest& from); + void MergeFrom(const QueryRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.EntityId entity_id = 1; + inline bool has_entity_id() const; + inline void clear_entity_id(); + static const int kEntityIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& entity_id() const; + inline ::bgs::protocol::EntityId* mutable_entity_id(); + inline ::bgs::protocol::EntityId* release_entity_id(); + inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id); + + // repeated .bgs.protocol.presence.v1.FieldKey key = 2; + inline int key_size() const; + inline void clear_key(); + static const int kKeyFieldNumber = 2; + inline const ::bgs::protocol::presence::v1::FieldKey& key(int index) const; + inline ::bgs::protocol::presence::v1::FieldKey* mutable_key(int index); + inline ::bgs::protocol::presence::v1::FieldKey* add_key(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldKey >& + key() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldKey >* + mutable_key(); + + // optional .bgs.protocol.EntityId agent_id = 3; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 3; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.QueryRequest) + private: + inline void set_has_entity_id(); + inline void clear_has_entity_id(); + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* entity_id_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldKey > key_; + ::bgs::protocol::EntityId* agent_id_; + friend void TC_SHARED_API protobuf_AddDesc_presence_5fservice_2eproto(); + friend void protobuf_AssignDesc_presence_5fservice_2eproto(); + friend void protobuf_ShutdownFile_presence_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static QueryRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API QueryResponse : public ::google::protobuf::Message { + public: + QueryResponse(); + virtual ~QueryResponse(); + + QueryResponse(const QueryResponse& from); + + inline QueryResponse& operator=(const QueryResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const QueryResponse& default_instance(); + + void Swap(QueryResponse* other); + + // implements Message ---------------------------------------------- + + QueryResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const QueryResponse& from); + void MergeFrom(const QueryResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.presence.v1.Field field = 2; + inline int field_size() const; + inline void clear_field(); + static const int kFieldFieldNumber = 2; + inline const ::bgs::protocol::presence::v1::Field& field(int index) const; + inline ::bgs::protocol::presence::v1::Field* mutable_field(int index); + inline ::bgs::protocol::presence::v1::Field* add_field(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::Field >& + field() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::Field >* + mutable_field(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.QueryResponse) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::Field > field_; + friend void TC_SHARED_API protobuf_AddDesc_presence_5fservice_2eproto(); + friend void protobuf_AssignDesc_presence_5fservice_2eproto(); + friend void protobuf_ShutdownFile_presence_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static QueryResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API OwnershipRequest : public ::google::protobuf::Message { + public: + OwnershipRequest(); + virtual ~OwnershipRequest(); + + OwnershipRequest(const OwnershipRequest& from); + + inline OwnershipRequest& operator=(const OwnershipRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const OwnershipRequest& default_instance(); + + void Swap(OwnershipRequest* other); + + // implements Message ---------------------------------------------- + + OwnershipRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const OwnershipRequest& from); + void MergeFrom(const OwnershipRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.EntityId entity_id = 1; + inline bool has_entity_id() const; + inline void clear_entity_id(); + static const int kEntityIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& entity_id() const; + inline ::bgs::protocol::EntityId* mutable_entity_id(); + inline ::bgs::protocol::EntityId* release_entity_id(); + inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id); + + // optional bool release_ownership = 2 [default = false]; + inline bool has_release_ownership() const; + inline void clear_release_ownership(); + static const int kReleaseOwnershipFieldNumber = 2; + inline bool release_ownership() const; + inline void set_release_ownership(bool value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.OwnershipRequest) + private: + inline void set_has_entity_id(); + inline void clear_has_entity_id(); + inline void set_has_release_ownership(); + inline void clear_has_release_ownership(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* entity_id_; + bool release_ownership_; + friend void TC_SHARED_API protobuf_AddDesc_presence_5fservice_2eproto(); + friend void protobuf_AssignDesc_presence_5fservice_2eproto(); + friend void protobuf_ShutdownFile_presence_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static OwnershipRequest* default_instance_; +}; +// =================================================================== + +class TC_SHARED_API PresenceService : public ServiceBase +{ + public: + + template + explicit PresenceService(HashSelector) : service_hash_(HashSelector::Result::value) { } + + typedef std::integral_constant OriginalHash; + typedef std::integral_constant NameHash; + + static google::protobuf::ServiceDescriptor const* descriptor(); + + // client methods -------------------------------------------------- + + void Subscribe(::bgs::protocol::presence::v1::SubscribeRequest const* request, std::function responseCallback); + void Unsubscribe(::bgs::protocol::presence::v1::UnsubscribeRequest const* request, std::function responseCallback); + void Update(::bgs::protocol::presence::v1::UpdateRequest const* request, std::function responseCallback); + void Query(::bgs::protocol::presence::v1::QueryRequest const* request, std::function responseCallback); + void Ownership(::bgs::protocol::presence::v1::OwnershipRequest const* request, std::function responseCallback); + void SubscribeNotification(::bgs::protocol::presence::v1::SubscribeNotificationRequest const* request, std::function responseCallback); + // server methods -------------------------------------------------- + + void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final; + + protected: + virtual uint32 HandleSubscribe(::bgs::protocol::presence::v1::SubscribeRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleUnsubscribe(::bgs::protocol::presence::v1::UnsubscribeRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleUpdate(::bgs::protocol::presence::v1::UpdateRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleQuery(::bgs::protocol::presence::v1::QueryRequest const* request, ::bgs::protocol::presence::v1::QueryResponse* response); + virtual uint32 HandleOwnership(::bgs::protocol::presence::v1::OwnershipRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleSubscribeNotification(::bgs::protocol::presence::v1::SubscribeNotificationRequest const* request, ::bgs::protocol::NoData* response); + + private: + uint32 service_hash_; + + GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(PresenceService); +}; + +// =================================================================== + + +// =================================================================== + +// SubscribeRequest + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool SubscribeRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SubscribeRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void SubscribeRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SubscribeRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& SubscribeRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.SubscribeRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* SubscribeRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.SubscribeRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* SubscribeRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void SubscribeRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.SubscribeRequest.agent_id) +} + +// required .bgs.protocol.EntityId entity_id = 2; +inline bool SubscribeRequest::has_entity_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void SubscribeRequest::set_has_entity_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void SubscribeRequest::clear_has_entity_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void SubscribeRequest::clear_entity_id() { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + clear_has_entity_id(); +} +inline const ::bgs::protocol::EntityId& SubscribeRequest::entity_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.SubscribeRequest.entity_id) + return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_; +} +inline ::bgs::protocol::EntityId* SubscribeRequest::mutable_entity_id() { + set_has_entity_id(); + if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.SubscribeRequest.entity_id) + return entity_id_; +} +inline ::bgs::protocol::EntityId* SubscribeRequest::release_entity_id() { + clear_has_entity_id(); + ::bgs::protocol::EntityId* temp = entity_id_; + entity_id_ = NULL; + return temp; +} +inline void SubscribeRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) { + delete entity_id_; + entity_id_ = entity_id; + if (entity_id) { + set_has_entity_id(); + } else { + clear_has_entity_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.SubscribeRequest.entity_id) +} + +// required uint64 object_id = 3; +inline bool SubscribeRequest::has_object_id() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void SubscribeRequest::set_has_object_id() { + _has_bits_[0] |= 0x00000004u; +} +inline void SubscribeRequest::clear_has_object_id() { + _has_bits_[0] &= ~0x00000004u; +} +inline void SubscribeRequest::clear_object_id() { + object_id_ = GOOGLE_ULONGLONG(0); + clear_has_object_id(); +} +inline ::google::protobuf::uint64 SubscribeRequest::object_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.SubscribeRequest.object_id) + return object_id_; +} +inline void SubscribeRequest::set_object_id(::google::protobuf::uint64 value) { + set_has_object_id(); + object_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.SubscribeRequest.object_id) +} + +// repeated fixed32 program = 4; +inline int SubscribeRequest::program_size() const { + return program_.size(); +} +inline void SubscribeRequest::clear_program() { + program_.Clear(); +} +inline ::google::protobuf::uint32 SubscribeRequest::program(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.SubscribeRequest.program) + return program_.Get(index); +} +inline void SubscribeRequest::set_program(int index, ::google::protobuf::uint32 value) { + program_.Set(index, value); + // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.SubscribeRequest.program) +} +inline void SubscribeRequest::add_program(::google::protobuf::uint32 value) { + program_.Add(value); + // @@protoc_insertion_point(field_add:bgs.protocol.presence.v1.SubscribeRequest.program) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +SubscribeRequest::program() const { + // @@protoc_insertion_point(field_list:bgs.protocol.presence.v1.SubscribeRequest.program) + return program_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +SubscribeRequest::mutable_program() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.presence.v1.SubscribeRequest.program) + return &program_; +} + +// optional bool flag_public = 5 [default = true, deprecated = true]; +inline bool SubscribeRequest::has_flag_public() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void SubscribeRequest::set_has_flag_public() { + _has_bits_[0] |= 0x00000010u; +} +inline void SubscribeRequest::clear_has_flag_public() { + _has_bits_[0] &= ~0x00000010u; +} +inline void SubscribeRequest::clear_flag_public() { + flag_public_ = true; + clear_has_flag_public(); +} +inline bool SubscribeRequest::flag_public() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.SubscribeRequest.flag_public) + return flag_public_; +} +inline void SubscribeRequest::set_flag_public(bool value) { + set_has_flag_public(); + flag_public_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.SubscribeRequest.flag_public) +} + +// ------------------------------------------------------------------- + +// SubscribeNotificationRequest + +// required .bgs.protocol.EntityId entity_id = 1; +inline bool SubscribeNotificationRequest::has_entity_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SubscribeNotificationRequest::set_has_entity_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void SubscribeNotificationRequest::clear_has_entity_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SubscribeNotificationRequest::clear_entity_id() { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + clear_has_entity_id(); +} +inline const ::bgs::protocol::EntityId& SubscribeNotificationRequest::entity_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.SubscribeNotificationRequest.entity_id) + return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_; +} +inline ::bgs::protocol::EntityId* SubscribeNotificationRequest::mutable_entity_id() { + set_has_entity_id(); + if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.SubscribeNotificationRequest.entity_id) + return entity_id_; +} +inline ::bgs::protocol::EntityId* SubscribeNotificationRequest::release_entity_id() { + clear_has_entity_id(); + ::bgs::protocol::EntityId* temp = entity_id_; + entity_id_ = NULL; + return temp; +} +inline void SubscribeNotificationRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) { + delete entity_id_; + entity_id_ = entity_id; + if (entity_id) { + set_has_entity_id(); + } else { + clear_has_entity_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.SubscribeNotificationRequest.entity_id) +} + +// ------------------------------------------------------------------- + +// UnsubscribeRequest + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool UnsubscribeRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void UnsubscribeRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void UnsubscribeRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void UnsubscribeRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& UnsubscribeRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.UnsubscribeRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* UnsubscribeRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.UnsubscribeRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* UnsubscribeRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void UnsubscribeRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.UnsubscribeRequest.agent_id) +} + +// required .bgs.protocol.EntityId entity_id = 2; +inline bool UnsubscribeRequest::has_entity_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void UnsubscribeRequest::set_has_entity_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void UnsubscribeRequest::clear_has_entity_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void UnsubscribeRequest::clear_entity_id() { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + clear_has_entity_id(); +} +inline const ::bgs::protocol::EntityId& UnsubscribeRequest::entity_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.UnsubscribeRequest.entity_id) + return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_; +} +inline ::bgs::protocol::EntityId* UnsubscribeRequest::mutable_entity_id() { + set_has_entity_id(); + if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.UnsubscribeRequest.entity_id) + return entity_id_; +} +inline ::bgs::protocol::EntityId* UnsubscribeRequest::release_entity_id() { + clear_has_entity_id(); + ::bgs::protocol::EntityId* temp = entity_id_; + entity_id_ = NULL; + return temp; +} +inline void UnsubscribeRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) { + delete entity_id_; + entity_id_ = entity_id; + if (entity_id) { + set_has_entity_id(); + } else { + clear_has_entity_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.UnsubscribeRequest.entity_id) +} + +// optional uint64 object_id = 3; +inline bool UnsubscribeRequest::has_object_id() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void UnsubscribeRequest::set_has_object_id() { + _has_bits_[0] |= 0x00000004u; +} +inline void UnsubscribeRequest::clear_has_object_id() { + _has_bits_[0] &= ~0x00000004u; +} +inline void UnsubscribeRequest::clear_object_id() { + object_id_ = GOOGLE_ULONGLONG(0); + clear_has_object_id(); +} +inline ::google::protobuf::uint64 UnsubscribeRequest::object_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.UnsubscribeRequest.object_id) + return object_id_; +} +inline void UnsubscribeRequest::set_object_id(::google::protobuf::uint64 value) { + set_has_object_id(); + object_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.UnsubscribeRequest.object_id) +} + +// ------------------------------------------------------------------- + +// UpdateRequest + +// required .bgs.protocol.EntityId entity_id = 1; +inline bool UpdateRequest::has_entity_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void UpdateRequest::set_has_entity_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void UpdateRequest::clear_has_entity_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void UpdateRequest::clear_entity_id() { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + clear_has_entity_id(); +} +inline const ::bgs::protocol::EntityId& UpdateRequest::entity_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.UpdateRequest.entity_id) + return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_; +} +inline ::bgs::protocol::EntityId* UpdateRequest::mutable_entity_id() { + set_has_entity_id(); + if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.UpdateRequest.entity_id) + return entity_id_; +} +inline ::bgs::protocol::EntityId* UpdateRequest::release_entity_id() { + clear_has_entity_id(); + ::bgs::protocol::EntityId* temp = entity_id_; + entity_id_ = NULL; + return temp; +} +inline void UpdateRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) { + delete entity_id_; + entity_id_ = entity_id; + if (entity_id) { + set_has_entity_id(); + } else { + clear_has_entity_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.UpdateRequest.entity_id) +} + +// repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2; +inline int UpdateRequest::field_operation_size() const { + return field_operation_.size(); +} +inline void UpdateRequest::clear_field_operation() { + field_operation_.Clear(); +} +inline const ::bgs::protocol::presence::v1::FieldOperation& UpdateRequest::field_operation(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.UpdateRequest.field_operation) + return field_operation_.Get(index); +} +inline ::bgs::protocol::presence::v1::FieldOperation* UpdateRequest::mutable_field_operation(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.UpdateRequest.field_operation) + return field_operation_.Mutable(index); +} +inline ::bgs::protocol::presence::v1::FieldOperation* UpdateRequest::add_field_operation() { + // @@protoc_insertion_point(field_add:bgs.protocol.presence.v1.UpdateRequest.field_operation) + return field_operation_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation >& +UpdateRequest::field_operation() const { + // @@protoc_insertion_point(field_list:bgs.protocol.presence.v1.UpdateRequest.field_operation) + return field_operation_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation >* +UpdateRequest::mutable_field_operation() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.presence.v1.UpdateRequest.field_operation) + return &field_operation_; +} + +// optional bool no_create = 3 [default = false]; +inline bool UpdateRequest::has_no_create() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void UpdateRequest::set_has_no_create() { + _has_bits_[0] |= 0x00000004u; +} +inline void UpdateRequest::clear_has_no_create() { + _has_bits_[0] &= ~0x00000004u; +} +inline void UpdateRequest::clear_no_create() { + no_create_ = false; + clear_has_no_create(); +} +inline bool UpdateRequest::no_create() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.UpdateRequest.no_create) + return no_create_; +} +inline void UpdateRequest::set_no_create(bool value) { + set_has_no_create(); + no_create_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.UpdateRequest.no_create) +} + +// optional .bgs.protocol.EntityId agent_id = 4; +inline bool UpdateRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void UpdateRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000008u; +} +inline void UpdateRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000008u; +} +inline void UpdateRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& UpdateRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.UpdateRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* UpdateRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.UpdateRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* UpdateRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void UpdateRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.UpdateRequest.agent_id) +} + +// ------------------------------------------------------------------- + +// QueryRequest + +// required .bgs.protocol.EntityId entity_id = 1; +inline bool QueryRequest::has_entity_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void QueryRequest::set_has_entity_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void QueryRequest::clear_has_entity_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void QueryRequest::clear_entity_id() { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + clear_has_entity_id(); +} +inline const ::bgs::protocol::EntityId& QueryRequest::entity_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.QueryRequest.entity_id) + return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_; +} +inline ::bgs::protocol::EntityId* QueryRequest::mutable_entity_id() { + set_has_entity_id(); + if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.QueryRequest.entity_id) + return entity_id_; +} +inline ::bgs::protocol::EntityId* QueryRequest::release_entity_id() { + clear_has_entity_id(); + ::bgs::protocol::EntityId* temp = entity_id_; + entity_id_ = NULL; + return temp; +} +inline void QueryRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) { + delete entity_id_; + entity_id_ = entity_id; + if (entity_id) { + set_has_entity_id(); + } else { + clear_has_entity_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.QueryRequest.entity_id) +} + +// repeated .bgs.protocol.presence.v1.FieldKey key = 2; +inline int QueryRequest::key_size() const { + return key_.size(); +} +inline void QueryRequest::clear_key() { + key_.Clear(); +} +inline const ::bgs::protocol::presence::v1::FieldKey& QueryRequest::key(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.QueryRequest.key) + return key_.Get(index); +} +inline ::bgs::protocol::presence::v1::FieldKey* QueryRequest::mutable_key(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.QueryRequest.key) + return key_.Mutable(index); +} +inline ::bgs::protocol::presence::v1::FieldKey* QueryRequest::add_key() { + // @@protoc_insertion_point(field_add:bgs.protocol.presence.v1.QueryRequest.key) + return key_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldKey >& +QueryRequest::key() const { + // @@protoc_insertion_point(field_list:bgs.protocol.presence.v1.QueryRequest.key) + return key_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldKey >* +QueryRequest::mutable_key() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.presence.v1.QueryRequest.key) + return &key_; +} + +// optional .bgs.protocol.EntityId agent_id = 3; +inline bool QueryRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void QueryRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000004u; +} +inline void QueryRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000004u; +} +inline void QueryRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& QueryRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.QueryRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* QueryRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.QueryRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* QueryRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void QueryRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.QueryRequest.agent_id) +} + +// ------------------------------------------------------------------- + +// QueryResponse + +// repeated .bgs.protocol.presence.v1.Field field = 2; +inline int QueryResponse::field_size() const { + return field_.size(); +} +inline void QueryResponse::clear_field() { + field_.Clear(); +} +inline const ::bgs::protocol::presence::v1::Field& QueryResponse::field(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.QueryResponse.field) + return field_.Get(index); +} +inline ::bgs::protocol::presence::v1::Field* QueryResponse::mutable_field(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.QueryResponse.field) + return field_.Mutable(index); +} +inline ::bgs::protocol::presence::v1::Field* QueryResponse::add_field() { + // @@protoc_insertion_point(field_add:bgs.protocol.presence.v1.QueryResponse.field) + return field_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::Field >& +QueryResponse::field() const { + // @@protoc_insertion_point(field_list:bgs.protocol.presence.v1.QueryResponse.field) + return field_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::Field >* +QueryResponse::mutable_field() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.presence.v1.QueryResponse.field) + return &field_; +} + +// ------------------------------------------------------------------- + +// OwnershipRequest + +// required .bgs.protocol.EntityId entity_id = 1; +inline bool OwnershipRequest::has_entity_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void OwnershipRequest::set_has_entity_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void OwnershipRequest::clear_has_entity_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void OwnershipRequest::clear_entity_id() { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + clear_has_entity_id(); +} +inline const ::bgs::protocol::EntityId& OwnershipRequest::entity_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.OwnershipRequest.entity_id) + return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_; +} +inline ::bgs::protocol::EntityId* OwnershipRequest::mutable_entity_id() { + set_has_entity_id(); + if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.OwnershipRequest.entity_id) + return entity_id_; +} +inline ::bgs::protocol::EntityId* OwnershipRequest::release_entity_id() { + clear_has_entity_id(); + ::bgs::protocol::EntityId* temp = entity_id_; + entity_id_ = NULL; + return temp; +} +inline void OwnershipRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) { + delete entity_id_; + entity_id_ = entity_id; + if (entity_id) { + set_has_entity_id(); + } else { + clear_has_entity_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.OwnershipRequest.entity_id) +} + +// optional bool release_ownership = 2 [default = false]; +inline bool OwnershipRequest::has_release_ownership() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void OwnershipRequest::set_has_release_ownership() { + _has_bits_[0] |= 0x00000002u; +} +inline void OwnershipRequest::clear_has_release_ownership() { + _has_bits_[0] &= ~0x00000002u; +} +inline void OwnershipRequest::clear_release_ownership() { + release_ownership_ = false; + clear_has_release_ownership(); +} +inline bool OwnershipRequest::release_ownership() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.OwnershipRequest.release_ownership) + return release_ownership_; +} +inline void OwnershipRequest::set_release_ownership(bool value) { + set_has_release_ownership(); + release_ownership_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.OwnershipRequest.release_ownership) +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace presence +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_presence_5fservice_2eproto__INCLUDED diff --git a/src/server/proto/Client/presence_types.pb.cc b/src/server/proto/Client/presence_types.pb.cc new file mode 100644 index 00000000000..e57ad02268b --- /dev/null +++ b/src/server/proto/Client/presence_types.pb.cc @@ -0,0 +1,1801 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: presence_types.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "presence_types.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { +namespace presence { +namespace v1 { + +namespace { + +const ::google::protobuf::Descriptor* RichPresenceLocalizationKey_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + RichPresenceLocalizationKey_reflection_ = NULL; +const ::google::protobuf::Descriptor* FieldKey_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + FieldKey_reflection_ = NULL; +const ::google::protobuf::Descriptor* Field_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Field_reflection_ = NULL; +const ::google::protobuf::Descriptor* FieldOperation_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + FieldOperation_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* FieldOperation_OperationType_descriptor_ = NULL; +const ::google::protobuf::Descriptor* ChannelState_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ChannelState_reflection_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_presence_5ftypes_2eproto() { + protobuf_AddDesc_presence_5ftypes_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "presence_types.proto"); + GOOGLE_CHECK(file != NULL); + RichPresenceLocalizationKey_descriptor_ = file->message_type(0); + static const int RichPresenceLocalizationKey_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RichPresenceLocalizationKey, program_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RichPresenceLocalizationKey, stream_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RichPresenceLocalizationKey, localization_id_), + }; + RichPresenceLocalizationKey_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + RichPresenceLocalizationKey_descriptor_, + RichPresenceLocalizationKey::default_instance_, + RichPresenceLocalizationKey_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RichPresenceLocalizationKey, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RichPresenceLocalizationKey, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(RichPresenceLocalizationKey)); + FieldKey_descriptor_ = file->message_type(1); + static const int FieldKey_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldKey, program_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldKey, group_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldKey, field_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldKey, unique_id_), + }; + FieldKey_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + FieldKey_descriptor_, + FieldKey::default_instance_, + FieldKey_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldKey, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldKey, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(FieldKey)); + Field_descriptor_ = file->message_type(2); + static const int Field_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Field, key_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Field, value_), + }; + Field_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Field_descriptor_, + Field::default_instance_, + Field_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Field, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Field, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Field)); + FieldOperation_descriptor_ = file->message_type(3); + static const int FieldOperation_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOperation, field_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOperation, operation_), + }; + FieldOperation_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + FieldOperation_descriptor_, + FieldOperation::default_instance_, + FieldOperation_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOperation, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOperation, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(FieldOperation)); + FieldOperation_OperationType_descriptor_ = FieldOperation_descriptor_->enum_type(0); + ChannelState_descriptor_ = file->message_type(4); + static const int ChannelState_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, entity_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, field_operation_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, healing_), + }; + ChannelState_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ChannelState_descriptor_, + ChannelState::default_instance_, + ChannelState_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ChannelState)); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_presence_5ftypes_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + RichPresenceLocalizationKey_descriptor_, &RichPresenceLocalizationKey::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + FieldKey_descriptor_, &FieldKey::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Field_descriptor_, &Field::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + FieldOperation_descriptor_, &FieldOperation::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ChannelState_descriptor_, &ChannelState::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_presence_5ftypes_2eproto() { + delete RichPresenceLocalizationKey::default_instance_; + delete RichPresenceLocalizationKey_reflection_; + delete FieldKey::default_instance_; + delete FieldKey_reflection_; + delete Field::default_instance_; + delete Field_reflection_; + delete FieldOperation::default_instance_; + delete FieldOperation_reflection_; + delete ChannelState::default_instance_; + delete ChannelState_reflection_; +} + +void protobuf_AddDesc_presence_5ftypes_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto(); + ::bgs::protocol::channel::v1::protobuf_AddDesc_channel_5ftypes_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\024presence_types.proto\022\030bgs.protocol.pre" + "sence.v1\032\025attribute_types.proto\032\022entity_" + "types.proto\032\023channel_types.proto\"W\n\033Rich" + "PresenceLocalizationKey\022\017\n\007program\030\001 \002(\007" + "\022\016\n\006stream\030\002 \002(\007\022\027\n\017localization_id\030\003 \002(" + "\r\"O\n\010FieldKey\022\017\n\007program\030\001 \002(\r\022\r\n\005group\030" + "\002 \002(\r\022\r\n\005field\030\003 \002(\r\022\024\n\tunique_id\030\004 \001(\004:" + "\0010\"^\n\005Field\022/\n\003key\030\001 \002(\0132\".bgs.protocol." + "presence.v1.FieldKey\022$\n\005value\030\002 \002(\0132\025.bg" + "s.protocol.Variant\"\265\001\n\016FieldOperation\022.\n" + "\005field\030\001 \002(\0132\037.bgs.protocol.presence.v1." + "Field\022N\n\toperation\030\002 \001(\01626.bgs.protocol." + "presence.v1.FieldOperation.OperationType" + ":\003SET\"#\n\rOperationType\022\007\n\003SET\020\000\022\t\n\005CLEAR" + "\020\001\"\365\001\n\014ChannelState\022)\n\tentity_id\030\001 \001(\0132\026" + ".bgs.protocol.EntityId\022A\n\017field_operatio" + "n\030\002 \003(\0132(.bgs.protocol.presence.v1.Field" + "Operation\022\026\n\007healing\030\003 \001(\010:\005false2_\n\010pre" + "sence\022%.bgs.protocol.channel.v1.ChannelS" + "tate\030e \001(\0132&.bgs.protocol.presence.v1.Ch" + "annelStateB\002H\001", 814); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "presence_types.proto", &protobuf_RegisterTypes); + RichPresenceLocalizationKey::default_instance_ = new RichPresenceLocalizationKey(); + FieldKey::default_instance_ = new FieldKey(); + Field::default_instance_ = new Field(); + FieldOperation::default_instance_ = new FieldOperation(); + ChannelState::default_instance_ = new ChannelState(); + RichPresenceLocalizationKey::default_instance_->InitAsDefaultInstance(); + FieldKey::default_instance_->InitAsDefaultInstance(); + Field::default_instance_->InitAsDefaultInstance(); + FieldOperation::default_instance_->InitAsDefaultInstance(); + ChannelState::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::ExtensionSet::RegisterMessageExtension( + &::bgs::protocol::channel::v1::ChannelState::default_instance(), + 101, 11, false, false, + &::bgs::protocol::presence::v1::ChannelState::default_instance()); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_presence_5ftypes_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_presence_5ftypes_2eproto { + StaticDescriptorInitializer_presence_5ftypes_2eproto() { + protobuf_AddDesc_presence_5ftypes_2eproto(); + } +} static_descriptor_initializer_presence_5ftypes_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int RichPresenceLocalizationKey::kProgramFieldNumber; +const int RichPresenceLocalizationKey::kStreamFieldNumber; +const int RichPresenceLocalizationKey::kLocalizationIdFieldNumber; +#endif // !_MSC_VER + +RichPresenceLocalizationKey::RichPresenceLocalizationKey() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.RichPresenceLocalizationKey) +} + +void RichPresenceLocalizationKey::InitAsDefaultInstance() { +} + +RichPresenceLocalizationKey::RichPresenceLocalizationKey(const RichPresenceLocalizationKey& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.RichPresenceLocalizationKey) +} + +void RichPresenceLocalizationKey::SharedCtor() { + _cached_size_ = 0; + program_ = 0u; + stream_ = 0u; + localization_id_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +RichPresenceLocalizationKey::~RichPresenceLocalizationKey() { + // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.RichPresenceLocalizationKey) + SharedDtor(); +} + +void RichPresenceLocalizationKey::SharedDtor() { + if (this != default_instance_) { + } +} + +void RichPresenceLocalizationKey::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* RichPresenceLocalizationKey::descriptor() { + protobuf_AssignDescriptorsOnce(); + return RichPresenceLocalizationKey_descriptor_; +} + +const RichPresenceLocalizationKey& RichPresenceLocalizationKey::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_presence_5ftypes_2eproto(); + return *default_instance_; +} + +RichPresenceLocalizationKey* RichPresenceLocalizationKey::default_instance_ = NULL; + +RichPresenceLocalizationKey* RichPresenceLocalizationKey::New() const { + return new RichPresenceLocalizationKey; +} + +void RichPresenceLocalizationKey::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(program_, localization_id_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool RichPresenceLocalizationKey::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.RichPresenceLocalizationKey) + 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)) { + // required fixed32 program = 1; + case 1: { + if (tag == 13) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &program_))); + set_has_program(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(21)) goto parse_stream; + break; + } + + // required fixed32 stream = 2; + case 2: { + if (tag == 21) { + parse_stream: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &stream_))); + set_has_stream(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_localization_id; + break; + } + + // required uint32 localization_id = 3; + case 3: { + if (tag == 24) { + parse_localization_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &localization_id_))); + set_has_localization_id(); + } 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:bgs.protocol.presence.v1.RichPresenceLocalizationKey) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.RichPresenceLocalizationKey) + return false; +#undef DO_ +} + +void RichPresenceLocalizationKey::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.RichPresenceLocalizationKey) + // required fixed32 program = 1; + if (has_program()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->program(), output); + } + + // required fixed32 stream = 2; + if (has_stream()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->stream(), output); + } + + // required uint32 localization_id = 3; + if (has_localization_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->localization_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.RichPresenceLocalizationKey) +} + +::google::protobuf::uint8* RichPresenceLocalizationKey::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.RichPresenceLocalizationKey) + // required fixed32 program = 1; + if (has_program()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->program(), target); + } + + // required fixed32 stream = 2; + if (has_stream()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->stream(), target); + } + + // required uint32 localization_id = 3; + if (has_localization_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->localization_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.RichPresenceLocalizationKey) + return target; +} + +int RichPresenceLocalizationKey::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed32 program = 1; + if (has_program()) { + total_size += 1 + 4; + } + + // required fixed32 stream = 2; + if (has_stream()) { + total_size += 1 + 4; + } + + // required uint32 localization_id = 3; + if (has_localization_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->localization_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void RichPresenceLocalizationKey::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const RichPresenceLocalizationKey* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void RichPresenceLocalizationKey::MergeFrom(const RichPresenceLocalizationKey& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_program()) { + set_program(from.program()); + } + if (from.has_stream()) { + set_stream(from.stream()); + } + if (from.has_localization_id()) { + set_localization_id(from.localization_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void RichPresenceLocalizationKey::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RichPresenceLocalizationKey::CopyFrom(const RichPresenceLocalizationKey& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RichPresenceLocalizationKey::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + return true; +} + +void RichPresenceLocalizationKey::Swap(RichPresenceLocalizationKey* other) { + if (other != this) { + std::swap(program_, other->program_); + std::swap(stream_, other->stream_); + std::swap(localization_id_, other->localization_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata RichPresenceLocalizationKey::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = RichPresenceLocalizationKey_descriptor_; + metadata.reflection = RichPresenceLocalizationKey_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int FieldKey::kProgramFieldNumber; +const int FieldKey::kGroupFieldNumber; +const int FieldKey::kFieldFieldNumber; +const int FieldKey::kUniqueIdFieldNumber; +#endif // !_MSC_VER + +FieldKey::FieldKey() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.FieldKey) +} + +void FieldKey::InitAsDefaultInstance() { +} + +FieldKey::FieldKey(const FieldKey& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.FieldKey) +} + +void FieldKey::SharedCtor() { + _cached_size_ = 0; + program_ = 0u; + group_ = 0u; + field_ = 0u; + unique_id_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +FieldKey::~FieldKey() { + // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.FieldKey) + SharedDtor(); +} + +void FieldKey::SharedDtor() { + if (this != default_instance_) { + } +} + +void FieldKey::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* FieldKey::descriptor() { + protobuf_AssignDescriptorsOnce(); + return FieldKey_descriptor_; +} + +const FieldKey& FieldKey::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_presence_5ftypes_2eproto(); + return *default_instance_; +} + +FieldKey* FieldKey::default_instance_ = NULL; + +FieldKey* FieldKey::New() const { + return new FieldKey; +} + +void FieldKey::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(program_, field_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool FieldKey::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.FieldKey) + 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)) { + // required uint32 program = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &program_))); + set_has_program(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_group; + break; + } + + // required uint32 group = 2; + case 2: { + if (tag == 16) { + parse_group: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &group_))); + set_has_group(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_field; + break; + } + + // required uint32 field = 3; + case 3: { + if (tag == 24) { + parse_field: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &field_))); + set_has_field(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_unique_id; + break; + } + + // optional uint64 unique_id = 4 [default = 0]; + case 4: { + if (tag == 32) { + parse_unique_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &unique_id_))); + set_has_unique_id(); + } 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:bgs.protocol.presence.v1.FieldKey) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.FieldKey) + return false; +#undef DO_ +} + +void FieldKey::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.FieldKey) + // required uint32 program = 1; + if (has_program()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->program(), output); + } + + // required uint32 group = 2; + if (has_group()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->group(), output); + } + + // required uint32 field = 3; + if (has_field()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->field(), output); + } + + // optional uint64 unique_id = 4 [default = 0]; + if (has_unique_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->unique_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.FieldKey) +} + +::google::protobuf::uint8* FieldKey::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.FieldKey) + // required uint32 program = 1; + if (has_program()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->program(), target); + } + + // required uint32 group = 2; + if (has_group()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->group(), target); + } + + // required uint32 field = 3; + if (has_field()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->field(), target); + } + + // optional uint64 unique_id = 4 [default = 0]; + if (has_unique_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->unique_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.FieldKey) + return target; +} + +int FieldKey::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required uint32 program = 1; + if (has_program()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->program()); + } + + // required uint32 group = 2; + if (has_group()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->group()); + } + + // required uint32 field = 3; + if (has_field()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->field()); + } + + // optional uint64 unique_id = 4 [default = 0]; + if (has_unique_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->unique_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void FieldKey::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const FieldKey* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void FieldKey::MergeFrom(const FieldKey& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_program()) { + set_program(from.program()); + } + if (from.has_group()) { + set_group(from.group()); + } + if (from.has_field()) { + set_field(from.field()); + } + if (from.has_unique_id()) { + set_unique_id(from.unique_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void FieldKey::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FieldKey::CopyFrom(const FieldKey& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FieldKey::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + return true; +} + +void FieldKey::Swap(FieldKey* other) { + if (other != this) { + std::swap(program_, other->program_); + std::swap(group_, other->group_); + std::swap(field_, other->field_); + std::swap(unique_id_, other->unique_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata FieldKey::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = FieldKey_descriptor_; + metadata.reflection = FieldKey_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int Field::kKeyFieldNumber; +const int Field::kValueFieldNumber; +#endif // !_MSC_VER + +Field::Field() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.Field) +} + +void Field::InitAsDefaultInstance() { + key_ = const_cast< ::bgs::protocol::presence::v1::FieldKey*>(&::bgs::protocol::presence::v1::FieldKey::default_instance()); + value_ = const_cast< ::bgs::protocol::Variant*>(&::bgs::protocol::Variant::default_instance()); +} + +Field::Field(const Field& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.Field) +} + +void Field::SharedCtor() { + _cached_size_ = 0; + key_ = NULL; + value_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Field::~Field() { + // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.Field) + SharedDtor(); +} + +void Field::SharedDtor() { + if (this != default_instance_) { + delete key_; + delete value_; + } +} + +void Field::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Field::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Field_descriptor_; +} + +const Field& Field::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_presence_5ftypes_2eproto(); + return *default_instance_; +} + +Field* Field::default_instance_ = NULL; + +Field* Field::New() const { + return new Field; +} + +void Field::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_key()) { + if (key_ != NULL) key_->::bgs::protocol::presence::v1::FieldKey::Clear(); + } + if (has_value()) { + if (value_ != NULL) value_->::bgs::protocol::Variant::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Field::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.Field) + 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)) { + // required .bgs.protocol.presence.v1.FieldKey key = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_key())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_value; + break; + } + + // required .bgs.protocol.Variant value = 2; + case 2: { + if (tag == 18) { + parse_value: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_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:bgs.protocol.presence.v1.Field) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.Field) + return false; +#undef DO_ +} + +void Field::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.Field) + // required .bgs.protocol.presence.v1.FieldKey key = 1; + if (has_key()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->key(), output); + } + + // required .bgs.protocol.Variant value = 2; + if (has_value()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->value(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.Field) +} + +::google::protobuf::uint8* Field::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.Field) + // required .bgs.protocol.presence.v1.FieldKey key = 1; + if (has_key()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->key(), target); + } + + // required .bgs.protocol.Variant value = 2; + if (has_value()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->value(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.Field) + return target; +} + +int Field::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.presence.v1.FieldKey key = 1; + if (has_key()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->key()); + } + + // required .bgs.protocol.Variant value = 2; + if (has_value()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + 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 Field::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Field* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Field::MergeFrom(const Field& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_key()) { + mutable_key()->::bgs::protocol::presence::v1::FieldKey::MergeFrom(from.key()); + } + if (from.has_value()) { + mutable_value()->::bgs::protocol::Variant::MergeFrom(from.value()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Field::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Field::CopyFrom(const Field& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Field::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + if (has_key()) { + if (!this->key().IsInitialized()) return false; + } + if (has_value()) { + if (!this->value().IsInitialized()) return false; + } + return true; +} + +void Field::Swap(Field* other) { + if (other != this) { + std::swap(key_, other->key_); + 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 Field::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Field_descriptor_; + metadata.reflection = Field_reflection_; + return metadata; +} + + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* FieldOperation_OperationType_descriptor() { + protobuf_AssignDescriptorsOnce(); + return FieldOperation_OperationType_descriptor_; +} +bool FieldOperation_OperationType_IsValid(int value) { + switch(value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#ifndef _MSC_VER +const FieldOperation_OperationType FieldOperation::SET; +const FieldOperation_OperationType FieldOperation::CLEAR; +const FieldOperation_OperationType FieldOperation::OperationType_MIN; +const FieldOperation_OperationType FieldOperation::OperationType_MAX; +const int FieldOperation::OperationType_ARRAYSIZE; +#endif // _MSC_VER +#ifndef _MSC_VER +const int FieldOperation::kFieldFieldNumber; +const int FieldOperation::kOperationFieldNumber; +#endif // !_MSC_VER + +FieldOperation::FieldOperation() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.FieldOperation) +} + +void FieldOperation::InitAsDefaultInstance() { + field_ = const_cast< ::bgs::protocol::presence::v1::Field*>(&::bgs::protocol::presence::v1::Field::default_instance()); +} + +FieldOperation::FieldOperation(const FieldOperation& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.FieldOperation) +} + +void FieldOperation::SharedCtor() { + _cached_size_ = 0; + field_ = NULL; + operation_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +FieldOperation::~FieldOperation() { + // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.FieldOperation) + SharedDtor(); +} + +void FieldOperation::SharedDtor() { + if (this != default_instance_) { + delete field_; + } +} + +void FieldOperation::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* FieldOperation::descriptor() { + protobuf_AssignDescriptorsOnce(); + return FieldOperation_descriptor_; +} + +const FieldOperation& FieldOperation::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_presence_5ftypes_2eproto(); + return *default_instance_; +} + +FieldOperation* FieldOperation::default_instance_ = NULL; + +FieldOperation* FieldOperation::New() const { + return new FieldOperation; +} + +void FieldOperation::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_field()) { + if (field_ != NULL) field_->::bgs::protocol::presence::v1::Field::Clear(); + } + operation_ = 0; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool FieldOperation::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.FieldOperation) + 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)) { + // required .bgs.protocol.presence.v1.Field field = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_field())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_operation; + break; + } + + // optional .bgs.protocol.presence.v1.FieldOperation.OperationType operation = 2 [default = SET]; + case 2: { + if (tag == 16) { + parse_operation: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::bgs::protocol::presence::v1::FieldOperation_OperationType_IsValid(value)) { + set_operation(static_cast< ::bgs::protocol::presence::v1::FieldOperation_OperationType >(value)); + } else { + mutable_unknown_fields()->AddVarint(2, 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:bgs.protocol.presence.v1.FieldOperation) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.FieldOperation) + return false; +#undef DO_ +} + +void FieldOperation::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.FieldOperation) + // required .bgs.protocol.presence.v1.Field field = 1; + if (has_field()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->field(), output); + } + + // optional .bgs.protocol.presence.v1.FieldOperation.OperationType operation = 2 [default = SET]; + if (has_operation()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 2, this->operation(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.FieldOperation) +} + +::google::protobuf::uint8* FieldOperation::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.FieldOperation) + // required .bgs.protocol.presence.v1.Field field = 1; + if (has_field()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->field(), target); + } + + // optional .bgs.protocol.presence.v1.FieldOperation.OperationType operation = 2 [default = SET]; + if (has_operation()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 2, this->operation(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.FieldOperation) + return target; +} + +int FieldOperation::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.presence.v1.Field field = 1; + if (has_field()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->field()); + } + + // optional .bgs.protocol.presence.v1.FieldOperation.OperationType operation = 2 [default = SET]; + if (has_operation()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->operation()); + } + + } + 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 FieldOperation::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const FieldOperation* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void FieldOperation::MergeFrom(const FieldOperation& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_field()) { + mutable_field()->::bgs::protocol::presence::v1::Field::MergeFrom(from.field()); + } + if (from.has_operation()) { + set_operation(from.operation()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void FieldOperation::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FieldOperation::CopyFrom(const FieldOperation& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FieldOperation::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_field()) { + if (!this->field().IsInitialized()) return false; + } + return true; +} + +void FieldOperation::Swap(FieldOperation* other) { + if (other != this) { + std::swap(field_, other->field_); + std::swap(operation_, other->operation_); + 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 FieldOperation::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = FieldOperation_descriptor_; + metadata.reflection = FieldOperation_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ChannelState::kEntityIdFieldNumber; +const int ChannelState::kFieldOperationFieldNumber; +const int ChannelState::kHealingFieldNumber; +#endif // !_MSC_VER + +#ifndef _MSC_VER +const int ChannelState::kPresenceFieldNumber; +#endif +::google::protobuf::internal::ExtensionIdentifier< ::bgs::protocol::channel::v1::ChannelState, + ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::presence::v1::ChannelState >, 11, false > + ChannelState::presence(kPresenceFieldNumber, ::bgs::protocol::presence::v1::ChannelState::default_instance()); +ChannelState::ChannelState() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.ChannelState) +} + +void ChannelState::InitAsDefaultInstance() { + entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +ChannelState::ChannelState(const ChannelState& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.ChannelState) +} + +void ChannelState::SharedCtor() { + _cached_size_ = 0; + entity_id_ = NULL; + healing_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ChannelState::~ChannelState() { + // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.ChannelState) + SharedDtor(); +} + +void ChannelState::SharedDtor() { + if (this != default_instance_) { + delete entity_id_; + } +} + +void ChannelState::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ChannelState::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ChannelState_descriptor_; +} + +const ChannelState& ChannelState::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_presence_5ftypes_2eproto(); + return *default_instance_; +} + +ChannelState* ChannelState::default_instance_ = NULL; + +ChannelState* ChannelState::New() const { + return new ChannelState; +} + +void ChannelState::Clear() { + if (_has_bits_[0 / 32] & 5) { + if (has_entity_id()) { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + } + healing_ = false; + } + field_operation_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ChannelState::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.ChannelState) + 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 .bgs.protocol.EntityId entity_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_entity_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_field_operation; + break; + } + + // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2; + case 2: { + if (tag == 18) { + parse_field_operation: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_field_operation())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_field_operation; + if (input->ExpectTag(24)) goto parse_healing; + break; + } + + // optional bool healing = 3 [default = false]; + case 3: { + if (tag == 24) { + parse_healing: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &healing_))); + set_has_healing(); + } 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:bgs.protocol.presence.v1.ChannelState) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.ChannelState) + return false; +#undef DO_ +} + +void ChannelState::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.ChannelState) + // optional .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->entity_id(), output); + } + + // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2; + for (int i = 0; i < this->field_operation_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->field_operation(i), output); + } + + // optional bool healing = 3 [default = false]; + if (has_healing()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->healing(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.ChannelState) +} + +::google::protobuf::uint8* ChannelState::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.ChannelState) + // optional .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->entity_id(), target); + } + + // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2; + for (int i = 0; i < this->field_operation_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->field_operation(i), target); + } + + // optional bool healing = 3 [default = false]; + if (has_healing()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->healing(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.ChannelState) + return target; +} + +int ChannelState::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->entity_id()); + } + + // optional bool healing = 3 [default = false]; + if (has_healing()) { + total_size += 1 + 1; + } + + } + // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2; + total_size += 1 * this->field_operation_size(); + for (int i = 0; i < this->field_operation_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->field_operation(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 ChannelState::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ChannelState* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ChannelState::MergeFrom(const ChannelState& from) { + GOOGLE_CHECK_NE(&from, this); + field_operation_.MergeFrom(from.field_operation_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_entity_id()) { + mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id()); + } + if (from.has_healing()) { + set_healing(from.healing()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ChannelState::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ChannelState::CopyFrom(const ChannelState& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ChannelState::IsInitialized() const { + + if (has_entity_id()) { + if (!this->entity_id().IsInitialized()) return false; + } + if (!::google::protobuf::internal::AllAreInitialized(this->field_operation())) return false; + return true; +} + +void ChannelState::Swap(ChannelState* other) { + if (other != this) { + std::swap(entity_id_, other->entity_id_); + field_operation_.Swap(&other->field_operation_); + std::swap(healing_, other->healing_); + 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 ChannelState::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ChannelState_descriptor_; + metadata.reflection = ChannelState_reflection_; + return metadata; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace presence +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/presence_types.pb.h b/src/server/proto/Client/presence_types.pb.h new file mode 100644 index 00000000000..c77b517bd58 --- /dev/null +++ b/src/server/proto/Client/presence_types.pb.h @@ -0,0 +1,1054 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: presence_types.proto + +#ifndef PROTOBUF_presence_5ftypes_2eproto__INCLUDED +#define PROTOBUF_presence_5ftypes_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include +#include "attribute_types.pb.h" +#include "entity_types.pb.h" +#include "channel_types.pb.h" +#include "Define.h" // for TRINITY_SHARED_API +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { +namespace presence { +namespace v1 { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_presence_5ftypes_2eproto(); +void protobuf_AssignDesc_presence_5ftypes_2eproto(); +void protobuf_ShutdownFile_presence_5ftypes_2eproto(); + +class RichPresenceLocalizationKey; +class FieldKey; +class Field; +class FieldOperation; +class ChannelState; + +enum FieldOperation_OperationType { + FieldOperation_OperationType_SET = 0, + FieldOperation_OperationType_CLEAR = 1 +}; +TC_SHARED_API bool FieldOperation_OperationType_IsValid(int value); +const FieldOperation_OperationType FieldOperation_OperationType_OperationType_MIN = FieldOperation_OperationType_SET; +const FieldOperation_OperationType FieldOperation_OperationType_OperationType_MAX = FieldOperation_OperationType_CLEAR; +const int FieldOperation_OperationType_OperationType_ARRAYSIZE = FieldOperation_OperationType_OperationType_MAX + 1; + +TC_SHARED_API const ::google::protobuf::EnumDescriptor* FieldOperation_OperationType_descriptor(); +inline const ::std::string& FieldOperation_OperationType_Name(FieldOperation_OperationType value) { + return ::google::protobuf::internal::NameOfEnum( + FieldOperation_OperationType_descriptor(), value); +} +inline bool FieldOperation_OperationType_Parse( + const ::std::string& name, FieldOperation_OperationType* value) { + return ::google::protobuf::internal::ParseNamedEnum( + FieldOperation_OperationType_descriptor(), name, value); +} +// =================================================================== + +class TC_SHARED_API RichPresenceLocalizationKey : public ::google::protobuf::Message { + public: + RichPresenceLocalizationKey(); + virtual ~RichPresenceLocalizationKey(); + + RichPresenceLocalizationKey(const RichPresenceLocalizationKey& from); + + inline RichPresenceLocalizationKey& operator=(const RichPresenceLocalizationKey& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const RichPresenceLocalizationKey& default_instance(); + + void Swap(RichPresenceLocalizationKey* other); + + // implements Message ---------------------------------------------- + + RichPresenceLocalizationKey* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const RichPresenceLocalizationKey& from); + void MergeFrom(const RichPresenceLocalizationKey& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed32 program = 1; + inline bool has_program() const; + inline void clear_program(); + static const int kProgramFieldNumber = 1; + inline ::google::protobuf::uint32 program() const; + inline void set_program(::google::protobuf::uint32 value); + + // required fixed32 stream = 2; + inline bool has_stream() const; + inline void clear_stream(); + static const int kStreamFieldNumber = 2; + inline ::google::protobuf::uint32 stream() const; + inline void set_stream(::google::protobuf::uint32 value); + + // required uint32 localization_id = 3; + inline bool has_localization_id() const; + inline void clear_localization_id(); + static const int kLocalizationIdFieldNumber = 3; + inline ::google::protobuf::uint32 localization_id() const; + inline void set_localization_id(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.RichPresenceLocalizationKey) + private: + inline void set_has_program(); + inline void clear_has_program(); + inline void set_has_stream(); + inline void clear_has_stream(); + inline void set_has_localization_id(); + inline void clear_has_localization_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 program_; + ::google::protobuf::uint32 stream_; + ::google::protobuf::uint32 localization_id_; + friend void TC_SHARED_API protobuf_AddDesc_presence_5ftypes_2eproto(); + friend void protobuf_AssignDesc_presence_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_presence_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static RichPresenceLocalizationKey* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API FieldKey : public ::google::protobuf::Message { + public: + FieldKey(); + virtual ~FieldKey(); + + FieldKey(const FieldKey& from); + + inline FieldKey& operator=(const FieldKey& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const FieldKey& default_instance(); + + void Swap(FieldKey* other); + + // implements Message ---------------------------------------------- + + FieldKey* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const FieldKey& from); + void MergeFrom(const FieldKey& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required uint32 program = 1; + inline bool has_program() const; + inline void clear_program(); + static const int kProgramFieldNumber = 1; + inline ::google::protobuf::uint32 program() const; + inline void set_program(::google::protobuf::uint32 value); + + // required uint32 group = 2; + inline bool has_group() const; + inline void clear_group(); + static const int kGroupFieldNumber = 2; + inline ::google::protobuf::uint32 group() const; + inline void set_group(::google::protobuf::uint32 value); + + // required uint32 field = 3; + inline bool has_field() const; + inline void clear_field(); + static const int kFieldFieldNumber = 3; + inline ::google::protobuf::uint32 field() const; + inline void set_field(::google::protobuf::uint32 value); + + // optional uint64 unique_id = 4 [default = 0]; + inline bool has_unique_id() const; + inline void clear_unique_id(); + static const int kUniqueIdFieldNumber = 4; + inline ::google::protobuf::uint64 unique_id() const; + inline void set_unique_id(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.FieldKey) + private: + inline void set_has_program(); + inline void clear_has_program(); + inline void set_has_group(); + inline void clear_has_group(); + inline void set_has_field(); + inline void clear_has_field(); + inline void set_has_unique_id(); + inline void clear_has_unique_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 program_; + ::google::protobuf::uint32 group_; + ::google::protobuf::uint64 unique_id_; + ::google::protobuf::uint32 field_; + friend void TC_SHARED_API protobuf_AddDesc_presence_5ftypes_2eproto(); + friend void protobuf_AssignDesc_presence_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_presence_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static FieldKey* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API Field : public ::google::protobuf::Message { + public: + Field(); + virtual ~Field(); + + Field(const Field& from); + + inline Field& operator=(const Field& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Field& default_instance(); + + void Swap(Field* other); + + // implements Message ---------------------------------------------- + + Field* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Field& from); + void MergeFrom(const Field& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.presence.v1.FieldKey key = 1; + inline bool has_key() const; + inline void clear_key(); + static const int kKeyFieldNumber = 1; + inline const ::bgs::protocol::presence::v1::FieldKey& key() const; + inline ::bgs::protocol::presence::v1::FieldKey* mutable_key(); + inline ::bgs::protocol::presence::v1::FieldKey* release_key(); + inline void set_allocated_key(::bgs::protocol::presence::v1::FieldKey* key); + + // required .bgs.protocol.Variant value = 2; + inline bool has_value() const; + inline void clear_value(); + static const int kValueFieldNumber = 2; + inline const ::bgs::protocol::Variant& value() const; + inline ::bgs::protocol::Variant* mutable_value(); + inline ::bgs::protocol::Variant* release_value(); + inline void set_allocated_value(::bgs::protocol::Variant* value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.Field) + private: + inline void set_has_key(); + inline void clear_has_key(); + inline void set_has_value(); + inline void clear_has_value(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::presence::v1::FieldKey* key_; + ::bgs::protocol::Variant* value_; + friend void TC_SHARED_API protobuf_AddDesc_presence_5ftypes_2eproto(); + friend void protobuf_AssignDesc_presence_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_presence_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static Field* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API FieldOperation : public ::google::protobuf::Message { + public: + FieldOperation(); + virtual ~FieldOperation(); + + FieldOperation(const FieldOperation& from); + + inline FieldOperation& operator=(const FieldOperation& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const FieldOperation& default_instance(); + + void Swap(FieldOperation* other); + + // implements Message ---------------------------------------------- + + FieldOperation* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const FieldOperation& from); + void MergeFrom(const FieldOperation& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef FieldOperation_OperationType OperationType; + static const OperationType SET = FieldOperation_OperationType_SET; + static const OperationType CLEAR = FieldOperation_OperationType_CLEAR; + static inline bool OperationType_IsValid(int value) { + return FieldOperation_OperationType_IsValid(value); + } + static const OperationType OperationType_MIN = + FieldOperation_OperationType_OperationType_MIN; + static const OperationType OperationType_MAX = + FieldOperation_OperationType_OperationType_MAX; + static const int OperationType_ARRAYSIZE = + FieldOperation_OperationType_OperationType_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + OperationType_descriptor() { + return FieldOperation_OperationType_descriptor(); + } + static inline const ::std::string& OperationType_Name(OperationType value) { + return FieldOperation_OperationType_Name(value); + } + static inline bool OperationType_Parse(const ::std::string& name, + OperationType* value) { + return FieldOperation_OperationType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.presence.v1.Field field = 1; + inline bool has_field() const; + inline void clear_field(); + static const int kFieldFieldNumber = 1; + inline const ::bgs::protocol::presence::v1::Field& field() const; + inline ::bgs::protocol::presence::v1::Field* mutable_field(); + inline ::bgs::protocol::presence::v1::Field* release_field(); + inline void set_allocated_field(::bgs::protocol::presence::v1::Field* field); + + // optional .bgs.protocol.presence.v1.FieldOperation.OperationType operation = 2 [default = SET]; + inline bool has_operation() const; + inline void clear_operation(); + static const int kOperationFieldNumber = 2; + inline ::bgs::protocol::presence::v1::FieldOperation_OperationType operation() const; + inline void set_operation(::bgs::protocol::presence::v1::FieldOperation_OperationType value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.FieldOperation) + private: + inline void set_has_field(); + inline void clear_has_field(); + inline void set_has_operation(); + inline void clear_has_operation(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::presence::v1::Field* field_; + int operation_; + friend void TC_SHARED_API protobuf_AddDesc_presence_5ftypes_2eproto(); + friend void protobuf_AssignDesc_presence_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_presence_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static FieldOperation* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ChannelState : public ::google::protobuf::Message { + public: + ChannelState(); + virtual ~ChannelState(); + + ChannelState(const ChannelState& from); + + inline ChannelState& operator=(const ChannelState& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ChannelState& default_instance(); + + void Swap(ChannelState* other); + + // implements Message ---------------------------------------------- + + ChannelState* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ChannelState& from); + void MergeFrom(const ChannelState& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId entity_id = 1; + inline bool has_entity_id() const; + inline void clear_entity_id(); + static const int kEntityIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& entity_id() const; + inline ::bgs::protocol::EntityId* mutable_entity_id(); + inline ::bgs::protocol::EntityId* release_entity_id(); + inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id); + + // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2; + inline int field_operation_size() const; + inline void clear_field_operation(); + static const int kFieldOperationFieldNumber = 2; + inline const ::bgs::protocol::presence::v1::FieldOperation& field_operation(int index) const; + inline ::bgs::protocol::presence::v1::FieldOperation* mutable_field_operation(int index); + inline ::bgs::protocol::presence::v1::FieldOperation* add_field_operation(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation >& + field_operation() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation >* + mutable_field_operation(); + + // optional bool healing = 3 [default = false]; + inline bool has_healing() const; + inline void clear_healing(); + static const int kHealingFieldNumber = 3; + inline bool healing() const; + inline void set_healing(bool value); + + static const int kPresenceFieldNumber = 101; + static ::google::protobuf::internal::ExtensionIdentifier< ::bgs::protocol::channel::v1::ChannelState, + ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::presence::v1::ChannelState >, 11, false > + presence; + // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.ChannelState) + private: + inline void set_has_entity_id(); + inline void clear_has_entity_id(); + inline void set_has_healing(); + inline void clear_has_healing(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* entity_id_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation > field_operation_; + bool healing_; + friend void TC_SHARED_API protobuf_AddDesc_presence_5ftypes_2eproto(); + friend void protobuf_AssignDesc_presence_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_presence_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static ChannelState* default_instance_; +}; +// =================================================================== + + +// =================================================================== + + +// =================================================================== + +// RichPresenceLocalizationKey + +// required fixed32 program = 1; +inline bool RichPresenceLocalizationKey::has_program() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void RichPresenceLocalizationKey::set_has_program() { + _has_bits_[0] |= 0x00000001u; +} +inline void RichPresenceLocalizationKey::clear_has_program() { + _has_bits_[0] &= ~0x00000001u; +} +inline void RichPresenceLocalizationKey::clear_program() { + program_ = 0u; + clear_has_program(); +} +inline ::google::protobuf::uint32 RichPresenceLocalizationKey::program() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.RichPresenceLocalizationKey.program) + return program_; +} +inline void RichPresenceLocalizationKey::set_program(::google::protobuf::uint32 value) { + set_has_program(); + program_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.RichPresenceLocalizationKey.program) +} + +// required fixed32 stream = 2; +inline bool RichPresenceLocalizationKey::has_stream() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void RichPresenceLocalizationKey::set_has_stream() { + _has_bits_[0] |= 0x00000002u; +} +inline void RichPresenceLocalizationKey::clear_has_stream() { + _has_bits_[0] &= ~0x00000002u; +} +inline void RichPresenceLocalizationKey::clear_stream() { + stream_ = 0u; + clear_has_stream(); +} +inline ::google::protobuf::uint32 RichPresenceLocalizationKey::stream() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.RichPresenceLocalizationKey.stream) + return stream_; +} +inline void RichPresenceLocalizationKey::set_stream(::google::protobuf::uint32 value) { + set_has_stream(); + stream_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.RichPresenceLocalizationKey.stream) +} + +// required uint32 localization_id = 3; +inline bool RichPresenceLocalizationKey::has_localization_id() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void RichPresenceLocalizationKey::set_has_localization_id() { + _has_bits_[0] |= 0x00000004u; +} +inline void RichPresenceLocalizationKey::clear_has_localization_id() { + _has_bits_[0] &= ~0x00000004u; +} +inline void RichPresenceLocalizationKey::clear_localization_id() { + localization_id_ = 0u; + clear_has_localization_id(); +} +inline ::google::protobuf::uint32 RichPresenceLocalizationKey::localization_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.RichPresenceLocalizationKey.localization_id) + return localization_id_; +} +inline void RichPresenceLocalizationKey::set_localization_id(::google::protobuf::uint32 value) { + set_has_localization_id(); + localization_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.RichPresenceLocalizationKey.localization_id) +} + +// ------------------------------------------------------------------- + +// FieldKey + +// required uint32 program = 1; +inline bool FieldKey::has_program() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void FieldKey::set_has_program() { + _has_bits_[0] |= 0x00000001u; +} +inline void FieldKey::clear_has_program() { + _has_bits_[0] &= ~0x00000001u; +} +inline void FieldKey::clear_program() { + program_ = 0u; + clear_has_program(); +} +inline ::google::protobuf::uint32 FieldKey::program() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.FieldKey.program) + return program_; +} +inline void FieldKey::set_program(::google::protobuf::uint32 value) { + set_has_program(); + program_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.FieldKey.program) +} + +// required uint32 group = 2; +inline bool FieldKey::has_group() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void FieldKey::set_has_group() { + _has_bits_[0] |= 0x00000002u; +} +inline void FieldKey::clear_has_group() { + _has_bits_[0] &= ~0x00000002u; +} +inline void FieldKey::clear_group() { + group_ = 0u; + clear_has_group(); +} +inline ::google::protobuf::uint32 FieldKey::group() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.FieldKey.group) + return group_; +} +inline void FieldKey::set_group(::google::protobuf::uint32 value) { + set_has_group(); + group_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.FieldKey.group) +} + +// required uint32 field = 3; +inline bool FieldKey::has_field() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void FieldKey::set_has_field() { + _has_bits_[0] |= 0x00000004u; +} +inline void FieldKey::clear_has_field() { + _has_bits_[0] &= ~0x00000004u; +} +inline void FieldKey::clear_field() { + field_ = 0u; + clear_has_field(); +} +inline ::google::protobuf::uint32 FieldKey::field() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.FieldKey.field) + return field_; +} +inline void FieldKey::set_field(::google::protobuf::uint32 value) { + set_has_field(); + field_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.FieldKey.field) +} + +// optional uint64 unique_id = 4 [default = 0]; +inline bool FieldKey::has_unique_id() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void FieldKey::set_has_unique_id() { + _has_bits_[0] |= 0x00000008u; +} +inline void FieldKey::clear_has_unique_id() { + _has_bits_[0] &= ~0x00000008u; +} +inline void FieldKey::clear_unique_id() { + unique_id_ = GOOGLE_ULONGLONG(0); + clear_has_unique_id(); +} +inline ::google::protobuf::uint64 FieldKey::unique_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.FieldKey.unique_id) + return unique_id_; +} +inline void FieldKey::set_unique_id(::google::protobuf::uint64 value) { + set_has_unique_id(); + unique_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.FieldKey.unique_id) +} + +// ------------------------------------------------------------------- + +// Field + +// required .bgs.protocol.presence.v1.FieldKey key = 1; +inline bool Field::has_key() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Field::set_has_key() { + _has_bits_[0] |= 0x00000001u; +} +inline void Field::clear_has_key() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Field::clear_key() { + if (key_ != NULL) key_->::bgs::protocol::presence::v1::FieldKey::Clear(); + clear_has_key(); +} +inline const ::bgs::protocol::presence::v1::FieldKey& Field::key() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.Field.key) + return key_ != NULL ? *key_ : *default_instance_->key_; +} +inline ::bgs::protocol::presence::v1::FieldKey* Field::mutable_key() { + set_has_key(); + if (key_ == NULL) key_ = new ::bgs::protocol::presence::v1::FieldKey; + // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.Field.key) + return key_; +} +inline ::bgs::protocol::presence::v1::FieldKey* Field::release_key() { + clear_has_key(); + ::bgs::protocol::presence::v1::FieldKey* temp = key_; + key_ = NULL; + return temp; +} +inline void Field::set_allocated_key(::bgs::protocol::presence::v1::FieldKey* key) { + delete key_; + key_ = key; + if (key) { + set_has_key(); + } else { + clear_has_key(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.Field.key) +} + +// required .bgs.protocol.Variant value = 2; +inline bool Field::has_value() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Field::set_has_value() { + _has_bits_[0] |= 0x00000002u; +} +inline void Field::clear_has_value() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Field::clear_value() { + if (value_ != NULL) value_->::bgs::protocol::Variant::Clear(); + clear_has_value(); +} +inline const ::bgs::protocol::Variant& Field::value() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.Field.value) + return value_ != NULL ? *value_ : *default_instance_->value_; +} +inline ::bgs::protocol::Variant* Field::mutable_value() { + set_has_value(); + if (value_ == NULL) value_ = new ::bgs::protocol::Variant; + // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.Field.value) + return value_; +} +inline ::bgs::protocol::Variant* Field::release_value() { + clear_has_value(); + ::bgs::protocol::Variant* temp = value_; + value_ = NULL; + return temp; +} +inline void Field::set_allocated_value(::bgs::protocol::Variant* value) { + delete value_; + value_ = value; + if (value) { + set_has_value(); + } else { + clear_has_value(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.Field.value) +} + +// ------------------------------------------------------------------- + +// FieldOperation + +// required .bgs.protocol.presence.v1.Field field = 1; +inline bool FieldOperation::has_field() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void FieldOperation::set_has_field() { + _has_bits_[0] |= 0x00000001u; +} +inline void FieldOperation::clear_has_field() { + _has_bits_[0] &= ~0x00000001u; +} +inline void FieldOperation::clear_field() { + if (field_ != NULL) field_->::bgs::protocol::presence::v1::Field::Clear(); + clear_has_field(); +} +inline const ::bgs::protocol::presence::v1::Field& FieldOperation::field() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.FieldOperation.field) + return field_ != NULL ? *field_ : *default_instance_->field_; +} +inline ::bgs::protocol::presence::v1::Field* FieldOperation::mutable_field() { + set_has_field(); + if (field_ == NULL) field_ = new ::bgs::protocol::presence::v1::Field; + // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.FieldOperation.field) + return field_; +} +inline ::bgs::protocol::presence::v1::Field* FieldOperation::release_field() { + clear_has_field(); + ::bgs::protocol::presence::v1::Field* temp = field_; + field_ = NULL; + return temp; +} +inline void FieldOperation::set_allocated_field(::bgs::protocol::presence::v1::Field* field) { + delete field_; + field_ = field; + if (field) { + set_has_field(); + } else { + clear_has_field(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.FieldOperation.field) +} + +// optional .bgs.protocol.presence.v1.FieldOperation.OperationType operation = 2 [default = SET]; +inline bool FieldOperation::has_operation() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void FieldOperation::set_has_operation() { + _has_bits_[0] |= 0x00000002u; +} +inline void FieldOperation::clear_has_operation() { + _has_bits_[0] &= ~0x00000002u; +} +inline void FieldOperation::clear_operation() { + operation_ = 0; + clear_has_operation(); +} +inline ::bgs::protocol::presence::v1::FieldOperation_OperationType FieldOperation::operation() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.FieldOperation.operation) + return static_cast< ::bgs::protocol::presence::v1::FieldOperation_OperationType >(operation_); +} +inline void FieldOperation::set_operation(::bgs::protocol::presence::v1::FieldOperation_OperationType value) { + assert(::bgs::protocol::presence::v1::FieldOperation_OperationType_IsValid(value)); + set_has_operation(); + operation_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.FieldOperation.operation) +} + +// ------------------------------------------------------------------- + +// ChannelState + +// optional .bgs.protocol.EntityId entity_id = 1; +inline bool ChannelState::has_entity_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ChannelState::set_has_entity_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void ChannelState::clear_has_entity_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ChannelState::clear_entity_id() { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + clear_has_entity_id(); +} +inline const ::bgs::protocol::EntityId& ChannelState::entity_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.ChannelState.entity_id) + return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_; +} +inline ::bgs::protocol::EntityId* ChannelState::mutable_entity_id() { + set_has_entity_id(); + if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.ChannelState.entity_id) + return entity_id_; +} +inline ::bgs::protocol::EntityId* ChannelState::release_entity_id() { + clear_has_entity_id(); + ::bgs::protocol::EntityId* temp = entity_id_; + entity_id_ = NULL; + return temp; +} +inline void ChannelState::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) { + delete entity_id_; + entity_id_ = entity_id; + if (entity_id) { + set_has_entity_id(); + } else { + clear_has_entity_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.ChannelState.entity_id) +} + +// repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2; +inline int ChannelState::field_operation_size() const { + return field_operation_.size(); +} +inline void ChannelState::clear_field_operation() { + field_operation_.Clear(); +} +inline const ::bgs::protocol::presence::v1::FieldOperation& ChannelState::field_operation(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.ChannelState.field_operation) + return field_operation_.Get(index); +} +inline ::bgs::protocol::presence::v1::FieldOperation* ChannelState::mutable_field_operation(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.ChannelState.field_operation) + return field_operation_.Mutable(index); +} +inline ::bgs::protocol::presence::v1::FieldOperation* ChannelState::add_field_operation() { + // @@protoc_insertion_point(field_add:bgs.protocol.presence.v1.ChannelState.field_operation) + return field_operation_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation >& +ChannelState::field_operation() const { + // @@protoc_insertion_point(field_list:bgs.protocol.presence.v1.ChannelState.field_operation) + return field_operation_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation >* +ChannelState::mutable_field_operation() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.presence.v1.ChannelState.field_operation) + return &field_operation_; +} + +// optional bool healing = 3 [default = false]; +inline bool ChannelState::has_healing() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ChannelState::set_has_healing() { + _has_bits_[0] |= 0x00000004u; +} +inline void ChannelState::clear_has_healing() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ChannelState::clear_healing() { + healing_ = false; + clear_has_healing(); +} +inline bool ChannelState::healing() const { + // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.ChannelState.healing) + return healing_; +} +inline void ChannelState::set_healing(bool value) { + set_has_healing(); + healing_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.ChannelState.healing) +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace presence +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + +template <> struct is_proto_enum< ::bgs::protocol::presence::v1::FieldOperation_OperationType> : ::google::protobuf::internal::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::presence::v1::FieldOperation_OperationType>() { + return ::bgs::protocol::presence::v1::FieldOperation_OperationType_descriptor(); +} + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_presence_5ftypes_2eproto__INCLUDED diff --git a/src/server/proto/Client/profanity_filter_config.pb.cc b/src/server/proto/Client/profanity_filter_config.pb.cc new file mode 100644 index 00000000000..dfd5c1e0fac --- /dev/null +++ b/src/server/proto/Client/profanity_filter_config.pb.cc @@ -0,0 +1,667 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: profanity_filter_config.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "profanity_filter_config.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { +namespace profanity { +namespace v1 { + +namespace { + +const ::google::protobuf::Descriptor* WordFilter_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + WordFilter_reflection_ = NULL; +const ::google::protobuf::Descriptor* WordFilters_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + WordFilters_reflection_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_profanity_5ffilter_5fconfig_2eproto() { + protobuf_AddDesc_profanity_5ffilter_5fconfig_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "profanity_filter_config.proto"); + GOOGLE_CHECK(file != NULL); + WordFilter_descriptor_ = file->message_type(0); + static const int WordFilter_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WordFilter, type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WordFilter, regex_), + }; + WordFilter_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + WordFilter_descriptor_, + WordFilter::default_instance_, + WordFilter_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WordFilter, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WordFilter, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(WordFilter)); + WordFilters_descriptor_ = file->message_type(1); + static const int WordFilters_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WordFilters, filters_), + }; + WordFilters_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + WordFilters_descriptor_, + WordFilters::default_instance_, + WordFilters_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WordFilters, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WordFilters, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(WordFilters)); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_profanity_5ffilter_5fconfig_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + WordFilter_descriptor_, &WordFilter::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + WordFilters_descriptor_, &WordFilters::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_profanity_5ffilter_5fconfig_2eproto() { + delete WordFilter::default_instance_; + delete WordFilter_reflection_; + delete WordFilters::default_instance_; + delete WordFilters_reflection_; +} + +void protobuf_AddDesc_profanity_5ffilter_5fconfig_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\035profanity_filter_config.proto\022\031bgs.pro" + "tocol.profanity.v1\")\n\nWordFilter\022\014\n\004type" + "\030\001 \002(\t\022\r\n\005regex\030\002 \002(\t\"E\n\013WordFilters\0226\n\007" + "filters\030\001 \003(\0132%.bgs.protocol.profanity.v" + "1.WordFilterB\002H\001", 176); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "profanity_filter_config.proto", &protobuf_RegisterTypes); + WordFilter::default_instance_ = new WordFilter(); + WordFilters::default_instance_ = new WordFilters(); + WordFilter::default_instance_->InitAsDefaultInstance(); + WordFilters::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_profanity_5ffilter_5fconfig_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_profanity_5ffilter_5fconfig_2eproto { + StaticDescriptorInitializer_profanity_5ffilter_5fconfig_2eproto() { + protobuf_AddDesc_profanity_5ffilter_5fconfig_2eproto(); + } +} static_descriptor_initializer_profanity_5ffilter_5fconfig_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int WordFilter::kTypeFieldNumber; +const int WordFilter::kRegexFieldNumber; +#endif // !_MSC_VER + +WordFilter::WordFilter() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.profanity.v1.WordFilter) +} + +void WordFilter::InitAsDefaultInstance() { +} + +WordFilter::WordFilter(const WordFilter& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.profanity.v1.WordFilter) +} + +void WordFilter::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + regex_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +WordFilter::~WordFilter() { + // @@protoc_insertion_point(destructor:bgs.protocol.profanity.v1.WordFilter) + SharedDtor(); +} + +void WordFilter::SharedDtor() { + if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete type_; + } + if (regex_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete regex_; + } + if (this != default_instance_) { + } +} + +void WordFilter::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* WordFilter::descriptor() { + protobuf_AssignDescriptorsOnce(); + return WordFilter_descriptor_; +} + +const WordFilter& WordFilter::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_profanity_5ffilter_5fconfig_2eproto(); + return *default_instance_; +} + +WordFilter* WordFilter::default_instance_ = NULL; + +WordFilter* WordFilter::New() const { + return new WordFilter; +} + +void WordFilter::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_type()) { + if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + type_->clear(); + } + } + if (has_regex()) { + if (regex_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + regex_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool WordFilter::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.profanity.v1.WordFilter) + 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)) { + // required string type = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_type())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->type().data(), this->type().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "type"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_regex; + break; + } + + // required string regex = 2; + case 2: { + if (tag == 18) { + parse_regex: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_regex())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->regex().data(), this->regex().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "regex"); + } 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:bgs.protocol.profanity.v1.WordFilter) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.profanity.v1.WordFilter) + return false; +#undef DO_ +} + +void WordFilter::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.profanity.v1.WordFilter) + // required string type = 1; + if (has_type()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->type().data(), this->type().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "type"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->type(), output); + } + + // required string regex = 2; + if (has_regex()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->regex().data(), this->regex().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "regex"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->regex(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.profanity.v1.WordFilter) +} + +::google::protobuf::uint8* WordFilter::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.profanity.v1.WordFilter) + // required string type = 1; + if (has_type()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->type().data(), this->type().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "type"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->type(), target); + } + + // required string regex = 2; + if (has_regex()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->regex().data(), this->regex().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "regex"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->regex(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.profanity.v1.WordFilter) + return target; +} + +int WordFilter::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string type = 1; + if (has_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->type()); + } + + // required string regex = 2; + if (has_regex()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->regex()); + } + + } + 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 WordFilter::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const WordFilter* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void WordFilter::MergeFrom(const WordFilter& 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_regex()) { + set_regex(from.regex()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void WordFilter::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void WordFilter::CopyFrom(const WordFilter& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool WordFilter::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void WordFilter::Swap(WordFilter* other) { + if (other != this) { + std::swap(type_, other->type_); + std::swap(regex_, other->regex_); + 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 WordFilter::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = WordFilter_descriptor_; + metadata.reflection = WordFilter_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int WordFilters::kFiltersFieldNumber; +#endif // !_MSC_VER + +WordFilters::WordFilters() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.profanity.v1.WordFilters) +} + +void WordFilters::InitAsDefaultInstance() { +} + +WordFilters::WordFilters(const WordFilters& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.profanity.v1.WordFilters) +} + +void WordFilters::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +WordFilters::~WordFilters() { + // @@protoc_insertion_point(destructor:bgs.protocol.profanity.v1.WordFilters) + SharedDtor(); +} + +void WordFilters::SharedDtor() { + if (this != default_instance_) { + } +} + +void WordFilters::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* WordFilters::descriptor() { + protobuf_AssignDescriptorsOnce(); + return WordFilters_descriptor_; +} + +const WordFilters& WordFilters::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_profanity_5ffilter_5fconfig_2eproto(); + return *default_instance_; +} + +WordFilters* WordFilters::default_instance_ = NULL; + +WordFilters* WordFilters::New() const { + return new WordFilters; +} + +void WordFilters::Clear() { + filters_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool WordFilters::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.profanity.v1.WordFilters) + 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 .bgs.protocol.profanity.v1.WordFilter filters = 1; + case 1: { + if (tag == 10) { + parse_filters: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_filters())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_filters; + 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:bgs.protocol.profanity.v1.WordFilters) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.profanity.v1.WordFilters) + return false; +#undef DO_ +} + +void WordFilters::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.profanity.v1.WordFilters) + // repeated .bgs.protocol.profanity.v1.WordFilter filters = 1; + for (int i = 0; i < this->filters_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->filters(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.profanity.v1.WordFilters) +} + +::google::protobuf::uint8* WordFilters::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.profanity.v1.WordFilters) + // repeated .bgs.protocol.profanity.v1.WordFilter filters = 1; + for (int i = 0; i < this->filters_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->filters(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.profanity.v1.WordFilters) + return target; +} + +int WordFilters::ByteSize() const { + int total_size = 0; + + // repeated .bgs.protocol.profanity.v1.WordFilter filters = 1; + total_size += 1 * this->filters_size(); + for (int i = 0; i < this->filters_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->filters(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 WordFilters::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const WordFilters* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void WordFilters::MergeFrom(const WordFilters& from) { + GOOGLE_CHECK_NE(&from, this); + filters_.MergeFrom(from.filters_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void WordFilters::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void WordFilters::CopyFrom(const WordFilters& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool WordFilters::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->filters())) return false; + return true; +} + +void WordFilters::Swap(WordFilters* other) { + if (other != this) { + filters_.Swap(&other->filters_); + 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 WordFilters::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = WordFilters_descriptor_; + metadata.reflection = WordFilters_reflection_; + return metadata; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace profanity +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/profanity_filter_config.pb.h b/src/server/proto/Client/profanity_filter_config.pb.h new file mode 100644 index 00000000000..ff3788f2c49 --- /dev/null +++ b/src/server/proto/Client/profanity_filter_config.pb.h @@ -0,0 +1,439 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: profanity_filter_config.proto + +#ifndef PROTOBUF_profanity_5ffilter_5fconfig_2eproto__INCLUDED +#define PROTOBUF_profanity_5ffilter_5fconfig_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include "Define.h" // for TRINITY_SHARED_API +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { +namespace profanity { +namespace v1 { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_profanity_5ffilter_5fconfig_2eproto(); +void protobuf_AssignDesc_profanity_5ffilter_5fconfig_2eproto(); +void protobuf_ShutdownFile_profanity_5ffilter_5fconfig_2eproto(); + +class WordFilter; +class WordFilters; + +// =================================================================== + +class TC_SHARED_API WordFilter : public ::google::protobuf::Message { + public: + WordFilter(); + virtual ~WordFilter(); + + WordFilter(const WordFilter& from); + + inline WordFilter& operator=(const WordFilter& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const WordFilter& default_instance(); + + void Swap(WordFilter* other); + + // implements Message ---------------------------------------------- + + WordFilter* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const WordFilter& from); + void MergeFrom(const WordFilter& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string type = 1; + inline bool has_type() const; + inline void clear_type(); + static const int kTypeFieldNumber = 1; + inline const ::std::string& type() const; + inline void set_type(const ::std::string& value); + inline void set_type(const char* value); + inline void set_type(const char* value, size_t size); + inline ::std::string* mutable_type(); + inline ::std::string* release_type(); + inline void set_allocated_type(::std::string* type); + + // required string regex = 2; + inline bool has_regex() const; + inline void clear_regex(); + static const int kRegexFieldNumber = 2; + inline const ::std::string& regex() const; + inline void set_regex(const ::std::string& value); + inline void set_regex(const char* value); + inline void set_regex(const char* value, size_t size); + inline ::std::string* mutable_regex(); + inline ::std::string* release_regex(); + inline void set_allocated_regex(::std::string* regex); + + // @@protoc_insertion_point(class_scope:bgs.protocol.profanity.v1.WordFilter) + private: + inline void set_has_type(); + inline void clear_has_type(); + inline void set_has_regex(); + inline void clear_has_regex(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* type_; + ::std::string* regex_; + friend void TC_SHARED_API protobuf_AddDesc_profanity_5ffilter_5fconfig_2eproto(); + friend void protobuf_AssignDesc_profanity_5ffilter_5fconfig_2eproto(); + friend void protobuf_ShutdownFile_profanity_5ffilter_5fconfig_2eproto(); + + void InitAsDefaultInstance(); + static WordFilter* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API WordFilters : public ::google::protobuf::Message { + public: + WordFilters(); + virtual ~WordFilters(); + + WordFilters(const WordFilters& from); + + inline WordFilters& operator=(const WordFilters& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const WordFilters& default_instance(); + + void Swap(WordFilters* other); + + // implements Message ---------------------------------------------- + + WordFilters* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const WordFilters& from); + void MergeFrom(const WordFilters& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.profanity.v1.WordFilter filters = 1; + inline int filters_size() const; + inline void clear_filters(); + static const int kFiltersFieldNumber = 1; + inline const ::bgs::protocol::profanity::v1::WordFilter& filters(int index) const; + inline ::bgs::protocol::profanity::v1::WordFilter* mutable_filters(int index); + inline ::bgs::protocol::profanity::v1::WordFilter* add_filters(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::profanity::v1::WordFilter >& + filters() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::profanity::v1::WordFilter >* + mutable_filters(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.profanity.v1.WordFilters) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::profanity::v1::WordFilter > filters_; + friend void TC_SHARED_API protobuf_AddDesc_profanity_5ffilter_5fconfig_2eproto(); + friend void protobuf_AssignDesc_profanity_5ffilter_5fconfig_2eproto(); + friend void protobuf_ShutdownFile_profanity_5ffilter_5fconfig_2eproto(); + + void InitAsDefaultInstance(); + static WordFilters* default_instance_; +}; +// =================================================================== + + +// =================================================================== + + +// =================================================================== + +// WordFilter + +// required string type = 1; +inline bool WordFilter::has_type() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void WordFilter::set_has_type() { + _has_bits_[0] |= 0x00000001u; +} +inline void WordFilter::clear_has_type() { + _has_bits_[0] &= ~0x00000001u; +} +inline void WordFilter::clear_type() { + if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + type_->clear(); + } + clear_has_type(); +} +inline const ::std::string& WordFilter::type() const { + // @@protoc_insertion_point(field_get:bgs.protocol.profanity.v1.WordFilter.type) + return *type_; +} +inline void WordFilter::set_type(const ::std::string& value) { + set_has_type(); + if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + type_ = new ::std::string; + } + type_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.profanity.v1.WordFilter.type) +} +inline void WordFilter::set_type(const char* value) { + set_has_type(); + if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + type_ = new ::std::string; + } + type_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.profanity.v1.WordFilter.type) +} +inline void WordFilter::set_type(const char* value, size_t size) { + set_has_type(); + if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + type_ = new ::std::string; + } + type_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.profanity.v1.WordFilter.type) +} +inline ::std::string* WordFilter::mutable_type() { + set_has_type(); + if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + type_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.profanity.v1.WordFilter.type) + return type_; +} +inline ::std::string* WordFilter::release_type() { + clear_has_type(); + if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = type_; + type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void WordFilter::set_allocated_type(::std::string* type) { + if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete type_; + } + if (type) { + set_has_type(); + type_ = type; + } else { + clear_has_type(); + type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.profanity.v1.WordFilter.type) +} + +// required string regex = 2; +inline bool WordFilter::has_regex() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void WordFilter::set_has_regex() { + _has_bits_[0] |= 0x00000002u; +} +inline void WordFilter::clear_has_regex() { + _has_bits_[0] &= ~0x00000002u; +} +inline void WordFilter::clear_regex() { + if (regex_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + regex_->clear(); + } + clear_has_regex(); +} +inline const ::std::string& WordFilter::regex() const { + // @@protoc_insertion_point(field_get:bgs.protocol.profanity.v1.WordFilter.regex) + return *regex_; +} +inline void WordFilter::set_regex(const ::std::string& value) { + set_has_regex(); + if (regex_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + regex_ = new ::std::string; + } + regex_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.profanity.v1.WordFilter.regex) +} +inline void WordFilter::set_regex(const char* value) { + set_has_regex(); + if (regex_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + regex_ = new ::std::string; + } + regex_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.profanity.v1.WordFilter.regex) +} +inline void WordFilter::set_regex(const char* value, size_t size) { + set_has_regex(); + if (regex_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + regex_ = new ::std::string; + } + regex_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.profanity.v1.WordFilter.regex) +} +inline ::std::string* WordFilter::mutable_regex() { + set_has_regex(); + if (regex_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + regex_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.profanity.v1.WordFilter.regex) + return regex_; +} +inline ::std::string* WordFilter::release_regex() { + clear_has_regex(); + if (regex_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = regex_; + regex_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void WordFilter::set_allocated_regex(::std::string* regex) { + if (regex_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete regex_; + } + if (regex) { + set_has_regex(); + regex_ = regex; + } else { + clear_has_regex(); + regex_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.profanity.v1.WordFilter.regex) +} + +// ------------------------------------------------------------------- + +// WordFilters + +// repeated .bgs.protocol.profanity.v1.WordFilter filters = 1; +inline int WordFilters::filters_size() const { + return filters_.size(); +} +inline void WordFilters::clear_filters() { + filters_.Clear(); +} +inline const ::bgs::protocol::profanity::v1::WordFilter& WordFilters::filters(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.profanity.v1.WordFilters.filters) + return filters_.Get(index); +} +inline ::bgs::protocol::profanity::v1::WordFilter* WordFilters::mutable_filters(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.profanity.v1.WordFilters.filters) + return filters_.Mutable(index); +} +inline ::bgs::protocol::profanity::v1::WordFilter* WordFilters::add_filters() { + // @@protoc_insertion_point(field_add:bgs.protocol.profanity.v1.WordFilters.filters) + return filters_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::profanity::v1::WordFilter >& +WordFilters::filters() const { + // @@protoc_insertion_point(field_list:bgs.protocol.profanity.v1.WordFilters.filters) + return filters_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::profanity::v1::WordFilter >* +WordFilters::mutable_filters() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.profanity.v1.WordFilters.filters) + return &filters_; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace profanity +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_profanity_5ffilter_5fconfig_2eproto__INCLUDED diff --git a/src/server/proto/Client/report_service.pb.cc b/src/server/proto/Client/report_service.pb.cc new file mode 100644 index 00000000000..216aeb23a2f --- /dev/null +++ b/src/server/proto/Client/report_service.pb.cc @@ -0,0 +1,912 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: report_service.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "report_service.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +#include "BattlenetRpcErrorCodes.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { +namespace report { +namespace v1 { + +namespace { + +const ::google::protobuf::Descriptor* Report_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Report_reflection_ = NULL; +const ::google::protobuf::Descriptor* SendReportRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SendReportRequest_reflection_ = NULL; +const ::google::protobuf::ServiceDescriptor* ReportService_descriptor_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_report_5fservice_2eproto() { + protobuf_AddDesc_report_5fservice_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "report_service.proto"); + GOOGLE_CHECK(file != NULL); + Report_descriptor_ = file->message_type(0); + static const int Report_offsets_[6] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Report, report_type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Report, attribute_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Report, report_qos_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Report, reporting_account_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Report, reporting_game_account_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Report, report_timestamp_), + }; + Report_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Report_descriptor_, + Report::default_instance_, + Report_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Report, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Report, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Report)); + SendReportRequest_descriptor_ = file->message_type(1); + static const int SendReportRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendReportRequest, report_), + }; + SendReportRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + SendReportRequest_descriptor_, + SendReportRequest::default_instance_, + SendReportRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendReportRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendReportRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(SendReportRequest)); + ReportService_descriptor_ = file->service(0); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_report_5fservice_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Report_descriptor_, &Report::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SendReportRequest_descriptor_, &SendReportRequest::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_report_5fservice_2eproto() { + delete Report::default_instance_; + delete Report_reflection_; + delete SendReportRequest::default_instance_; + delete SendReportRequest_reflection_; +} + +void protobuf_AddDesc_report_5fservice_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\024report_service.proto\022\026bgs.protocol.rep" + "ort.v1\032\025attribute_types.proto\032\022entity_ty" + "pes.proto\032\017rpc_types.proto\"\345\001\n\006Report\022\023\n" + "\013report_type\030\001 \002(\t\022*\n\tattribute\030\002 \003(\0132\027." + "bgs.protocol.Attribute\022\025\n\nreport_qos\030\003 \001" + "(\005:\0010\0221\n\021reporting_account\030\004 \001(\0132\026.bgs.p" + "rotocol.EntityId\0226\n\026reporting_game_accou" + "nt\030\005 \001(\0132\026.bgs.protocol.EntityId\022\030\n\020repo" + "rt_timestamp\030\006 \001(\006\"C\n\021SendReportRequest\022" + ".\n\006report\030\001 \002(\0132\036.bgs.protocol.report.v1" + ".Report2\213\001\n\rReportService\022S\n\nSendReport\022" + ").bgs.protocol.report.v1.SendReportReque" + "st\032\024.bgs.protocol.NoData\"\004\200\265\030\001\032%\312>\"bnet." + "protocol.report.ReportServiceB\005H\001\200\001\000", 556); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "report_service.proto", &protobuf_RegisterTypes); + Report::default_instance_ = new Report(); + SendReportRequest::default_instance_ = new SendReportRequest(); + Report::default_instance_->InitAsDefaultInstance(); + SendReportRequest::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_report_5fservice_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_report_5fservice_2eproto { + StaticDescriptorInitializer_report_5fservice_2eproto() { + protobuf_AddDesc_report_5fservice_2eproto(); + } +} static_descriptor_initializer_report_5fservice_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int Report::kReportTypeFieldNumber; +const int Report::kAttributeFieldNumber; +const int Report::kReportQosFieldNumber; +const int Report::kReportingAccountFieldNumber; +const int Report::kReportingGameAccountFieldNumber; +const int Report::kReportTimestampFieldNumber; +#endif // !_MSC_VER + +Report::Report() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.report.v1.Report) +} + +void Report::InitAsDefaultInstance() { + reporting_account_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + reporting_game_account_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +Report::Report(const Report& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.report.v1.Report) +} + +void Report::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + report_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + report_qos_ = 0; + reporting_account_ = NULL; + reporting_game_account_ = NULL; + report_timestamp_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Report::~Report() { + // @@protoc_insertion_point(destructor:bgs.protocol.report.v1.Report) + SharedDtor(); +} + +void Report::SharedDtor() { + if (report_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete report_type_; + } + if (this != default_instance_) { + delete reporting_account_; + delete reporting_game_account_; + } +} + +void Report::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Report::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Report_descriptor_; +} + +const Report& Report::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_report_5fservice_2eproto(); + return *default_instance_; +} + +Report* Report::default_instance_ = NULL; + +Report* Report::New() const { + return new Report; +} + +void Report::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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] & 61) { + ZR_(report_timestamp_, report_qos_); + if (has_report_type()) { + if (report_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + report_type_->clear(); + } + } + if (has_reporting_account()) { + if (reporting_account_ != NULL) reporting_account_->::bgs::protocol::EntityId::Clear(); + } + if (has_reporting_game_account()) { + if (reporting_game_account_ != NULL) reporting_game_account_->::bgs::protocol::EntityId::Clear(); + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + attribute_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Report::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.report.v1.Report) + 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)) { + // required string report_type = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_report_type())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->report_type().data(), this->report_type().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "report_type"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_attribute; + break; + } + + // repeated .bgs.protocol.Attribute attribute = 2; + case 2: { + if (tag == 18) { + parse_attribute: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_attribute())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_attribute; + if (input->ExpectTag(24)) goto parse_report_qos; + break; + } + + // optional int32 report_qos = 3 [default = 0]; + case 3: { + if (tag == 24) { + parse_report_qos: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &report_qos_))); + set_has_report_qos(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_reporting_account; + break; + } + + // optional .bgs.protocol.EntityId reporting_account = 4; + case 4: { + if (tag == 34) { + parse_reporting_account: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_reporting_account())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(42)) goto parse_reporting_game_account; + break; + } + + // optional .bgs.protocol.EntityId reporting_game_account = 5; + case 5: { + if (tag == 42) { + parse_reporting_game_account: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_reporting_game_account())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(49)) goto parse_report_timestamp; + break; + } + + // optional fixed64 report_timestamp = 6; + case 6: { + if (tag == 49) { + parse_report_timestamp: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &report_timestamp_))); + set_has_report_timestamp(); + } 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:bgs.protocol.report.v1.Report) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.report.v1.Report) + return false; +#undef DO_ +} + +void Report::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.report.v1.Report) + // required string report_type = 1; + if (has_report_type()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->report_type().data(), this->report_type().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "report_type"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->report_type(), output); + } + + // repeated .bgs.protocol.Attribute attribute = 2; + for (int i = 0; i < this->attribute_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->attribute(i), output); + } + + // optional int32 report_qos = 3 [default = 0]; + if (has_report_qos()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->report_qos(), output); + } + + // optional .bgs.protocol.EntityId reporting_account = 4; + if (has_reporting_account()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->reporting_account(), output); + } + + // optional .bgs.protocol.EntityId reporting_game_account = 5; + if (has_reporting_game_account()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, this->reporting_game_account(), output); + } + + // optional fixed64 report_timestamp = 6; + if (has_report_timestamp()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(6, this->report_timestamp(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.report.v1.Report) +} + +::google::protobuf::uint8* Report::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.report.v1.Report) + // required string report_type = 1; + if (has_report_type()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->report_type().data(), this->report_type().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "report_type"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->report_type(), target); + } + + // repeated .bgs.protocol.Attribute attribute = 2; + for (int i = 0; i < this->attribute_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->attribute(i), target); + } + + // optional int32 report_qos = 3 [default = 0]; + if (has_report_qos()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->report_qos(), target); + } + + // optional .bgs.protocol.EntityId reporting_account = 4; + if (has_reporting_account()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->reporting_account(), target); + } + + // optional .bgs.protocol.EntityId reporting_game_account = 5; + if (has_reporting_game_account()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 5, this->reporting_game_account(), target); + } + + // optional fixed64 report_timestamp = 6; + if (has_report_timestamp()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(6, this->report_timestamp(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.report.v1.Report) + return target; +} + +int Report::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string report_type = 1; + if (has_report_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->report_type()); + } + + // optional int32 report_qos = 3 [default = 0]; + if (has_report_qos()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->report_qos()); + } + + // optional .bgs.protocol.EntityId reporting_account = 4; + if (has_reporting_account()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->reporting_account()); + } + + // optional .bgs.protocol.EntityId reporting_game_account = 5; + if (has_reporting_game_account()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->reporting_game_account()); + } + + // optional fixed64 report_timestamp = 6; + if (has_report_timestamp()) { + total_size += 1 + 8; + } + + } + // repeated .bgs.protocol.Attribute attribute = 2; + total_size += 1 * this->attribute_size(); + for (int i = 0; i < this->attribute_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->attribute(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 Report::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Report* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Report::MergeFrom(const Report& from) { + GOOGLE_CHECK_NE(&from, this); + attribute_.MergeFrom(from.attribute_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_report_type()) { + set_report_type(from.report_type()); + } + if (from.has_report_qos()) { + set_report_qos(from.report_qos()); + } + if (from.has_reporting_account()) { + mutable_reporting_account()->::bgs::protocol::EntityId::MergeFrom(from.reporting_account()); + } + if (from.has_reporting_game_account()) { + mutable_reporting_game_account()->::bgs::protocol::EntityId::MergeFrom(from.reporting_game_account()); + } + if (from.has_report_timestamp()) { + set_report_timestamp(from.report_timestamp()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Report::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Report::CopyFrom(const Report& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Report::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false; + if (has_reporting_account()) { + if (!this->reporting_account().IsInitialized()) return false; + } + if (has_reporting_game_account()) { + if (!this->reporting_game_account().IsInitialized()) return false; + } + return true; +} + +void Report::Swap(Report* other) { + if (other != this) { + std::swap(report_type_, other->report_type_); + attribute_.Swap(&other->attribute_); + std::swap(report_qos_, other->report_qos_); + std::swap(reporting_account_, other->reporting_account_); + std::swap(reporting_game_account_, other->reporting_game_account_); + std::swap(report_timestamp_, other->report_timestamp_); + 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 Report::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Report_descriptor_; + metadata.reflection = Report_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int SendReportRequest::kReportFieldNumber; +#endif // !_MSC_VER + +SendReportRequest::SendReportRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.report.v1.SendReportRequest) +} + +void SendReportRequest::InitAsDefaultInstance() { + report_ = const_cast< ::bgs::protocol::report::v1::Report*>(&::bgs::protocol::report::v1::Report::default_instance()); +} + +SendReportRequest::SendReportRequest(const SendReportRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.report.v1.SendReportRequest) +} + +void SendReportRequest::SharedCtor() { + _cached_size_ = 0; + report_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +SendReportRequest::~SendReportRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.report.v1.SendReportRequest) + SharedDtor(); +} + +void SendReportRequest::SharedDtor() { + if (this != default_instance_) { + delete report_; + } +} + +void SendReportRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SendReportRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SendReportRequest_descriptor_; +} + +const SendReportRequest& SendReportRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_report_5fservice_2eproto(); + return *default_instance_; +} + +SendReportRequest* SendReportRequest::default_instance_ = NULL; + +SendReportRequest* SendReportRequest::New() const { + return new SendReportRequest; +} + +void SendReportRequest::Clear() { + if (has_report()) { + if (report_ != NULL) report_->::bgs::protocol::report::v1::Report::Clear(); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool SendReportRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.report.v1.SendReportRequest) + 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)) { + // required .bgs.protocol.report.v1.Report report = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_report())); + } 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:bgs.protocol.report.v1.SendReportRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.report.v1.SendReportRequest) + return false; +#undef DO_ +} + +void SendReportRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.report.v1.SendReportRequest) + // required .bgs.protocol.report.v1.Report report = 1; + if (has_report()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->report(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.report.v1.SendReportRequest) +} + +::google::protobuf::uint8* SendReportRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.report.v1.SendReportRequest) + // required .bgs.protocol.report.v1.Report report = 1; + if (has_report()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->report(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.report.v1.SendReportRequest) + return target; +} + +int SendReportRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.report.v1.Report report = 1; + if (has_report()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->report()); + } + + } + 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 SendReportRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const SendReportRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void SendReportRequest::MergeFrom(const SendReportRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_report()) { + mutable_report()->::bgs::protocol::report::v1::Report::MergeFrom(from.report()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void SendReportRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SendReportRequest::CopyFrom(const SendReportRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SendReportRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_report()) { + if (!this->report().IsInitialized()) return false; + } + return true; +} + +void SendReportRequest::Swap(SendReportRequest* other) { + if (other != this) { + std::swap(report_, other->report_); + 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 SendReportRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SendReportRequest_descriptor_; + metadata.reflection = SendReportRequest_reflection_; + return metadata; +} + + +// =================================================================== + +google::protobuf::ServiceDescriptor const* ReportService::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ReportService_descriptor_; +} + +void ReportService::SendReport(::bgs::protocol::report::v1::SendReportRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ReportService.SendReport(bgs.protocol.report.v1.SendReportRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 1, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void ReportService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) { + switch(methodId) { + case 1: { + ::bgs::protocol::report::v1::SendReportRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ReportService.SendReport server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleSendReport(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ReportService.SendReport(bgs.protocol.report.v1.SendReportRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 1, token, &response); + else + SendResponse(service_hash_, 1, token, status); + break; + } + default: + TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId); + SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD); + break; + } +} + +uint32 ReportService::HandleSendReport(::bgs::protocol::report::v1::SendReportRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ReportService.SendReport({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace report +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/report_service.pb.h b/src/server/proto/Client/report_service.pb.h new file mode 100644 index 00000000000..c078aa079f1 --- /dev/null +++ b/src/server/proto/Client/report_service.pb.h @@ -0,0 +1,608 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: report_service.proto + +#ifndef PROTOBUF_report_5fservice_2eproto__INCLUDED +#define PROTOBUF_report_5fservice_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include "attribute_types.pb.h" +#include "entity_types.pb.h" +#include "rpc_types.pb.h" +#include "ServiceBase.h" +#include "MessageBuffer.h" +#include +#include +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { +namespace report { +namespace v1 { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_report_5fservice_2eproto(); +void protobuf_AssignDesc_report_5fservice_2eproto(); +void protobuf_ShutdownFile_report_5fservice_2eproto(); + +class Report; +class SendReportRequest; + +// =================================================================== + +class TC_SHARED_API Report : public ::google::protobuf::Message { + public: + Report(); + virtual ~Report(); + + Report(const Report& from); + + inline Report& operator=(const Report& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Report& default_instance(); + + void Swap(Report* other); + + // implements Message ---------------------------------------------- + + Report* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Report& from); + void MergeFrom(const Report& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string report_type = 1; + inline bool has_report_type() const; + inline void clear_report_type(); + static const int kReportTypeFieldNumber = 1; + inline const ::std::string& report_type() const; + inline void set_report_type(const ::std::string& value); + inline void set_report_type(const char* value); + inline void set_report_type(const char* value, size_t size); + inline ::std::string* mutable_report_type(); + inline ::std::string* release_report_type(); + inline void set_allocated_report_type(::std::string* report_type); + + // repeated .bgs.protocol.Attribute attribute = 2; + inline int attribute_size() const; + inline void clear_attribute(); + static const int kAttributeFieldNumber = 2; + inline const ::bgs::protocol::Attribute& attribute(int index) const; + inline ::bgs::protocol::Attribute* mutable_attribute(int index); + inline ::bgs::protocol::Attribute* add_attribute(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& + attribute() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* + mutable_attribute(); + + // optional int32 report_qos = 3 [default = 0]; + inline bool has_report_qos() const; + inline void clear_report_qos(); + static const int kReportQosFieldNumber = 3; + inline ::google::protobuf::int32 report_qos() const; + inline void set_report_qos(::google::protobuf::int32 value); + + // optional .bgs.protocol.EntityId reporting_account = 4; + inline bool has_reporting_account() const; + inline void clear_reporting_account(); + static const int kReportingAccountFieldNumber = 4; + inline const ::bgs::protocol::EntityId& reporting_account() const; + inline ::bgs::protocol::EntityId* mutable_reporting_account(); + inline ::bgs::protocol::EntityId* release_reporting_account(); + inline void set_allocated_reporting_account(::bgs::protocol::EntityId* reporting_account); + + // optional .bgs.protocol.EntityId reporting_game_account = 5; + inline bool has_reporting_game_account() const; + inline void clear_reporting_game_account(); + static const int kReportingGameAccountFieldNumber = 5; + inline const ::bgs::protocol::EntityId& reporting_game_account() const; + inline ::bgs::protocol::EntityId* mutable_reporting_game_account(); + inline ::bgs::protocol::EntityId* release_reporting_game_account(); + inline void set_allocated_reporting_game_account(::bgs::protocol::EntityId* reporting_game_account); + + // optional fixed64 report_timestamp = 6; + inline bool has_report_timestamp() const; + inline void clear_report_timestamp(); + static const int kReportTimestampFieldNumber = 6; + inline ::google::protobuf::uint64 report_timestamp() const; + inline void set_report_timestamp(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.report.v1.Report) + private: + inline void set_has_report_type(); + inline void clear_has_report_type(); + inline void set_has_report_qos(); + inline void clear_has_report_qos(); + inline void set_has_reporting_account(); + inline void clear_has_reporting_account(); + inline void set_has_reporting_game_account(); + inline void clear_has_reporting_game_account(); + inline void set_has_report_timestamp(); + inline void clear_has_report_timestamp(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* report_type_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_; + ::bgs::protocol::EntityId* reporting_account_; + ::bgs::protocol::EntityId* reporting_game_account_; + ::google::protobuf::uint64 report_timestamp_; + ::google::protobuf::int32 report_qos_; + friend void TC_SHARED_API protobuf_AddDesc_report_5fservice_2eproto(); + friend void protobuf_AssignDesc_report_5fservice_2eproto(); + friend void protobuf_ShutdownFile_report_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static Report* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API SendReportRequest : public ::google::protobuf::Message { + public: + SendReportRequest(); + virtual ~SendReportRequest(); + + SendReportRequest(const SendReportRequest& from); + + inline SendReportRequest& operator=(const SendReportRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SendReportRequest& default_instance(); + + void Swap(SendReportRequest* other); + + // implements Message ---------------------------------------------- + + SendReportRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SendReportRequest& from); + void MergeFrom(const SendReportRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.report.v1.Report report = 1; + inline bool has_report() const; + inline void clear_report(); + static const int kReportFieldNumber = 1; + inline const ::bgs::protocol::report::v1::Report& report() const; + inline ::bgs::protocol::report::v1::Report* mutable_report(); + inline ::bgs::protocol::report::v1::Report* release_report(); + inline void set_allocated_report(::bgs::protocol::report::v1::Report* report); + + // @@protoc_insertion_point(class_scope:bgs.protocol.report.v1.SendReportRequest) + private: + inline void set_has_report(); + inline void clear_has_report(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::report::v1::Report* report_; + friend void TC_SHARED_API protobuf_AddDesc_report_5fservice_2eproto(); + friend void protobuf_AssignDesc_report_5fservice_2eproto(); + friend void protobuf_ShutdownFile_report_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static SendReportRequest* default_instance_; +}; +// =================================================================== + +class TC_SHARED_API ReportService : public ServiceBase +{ + public: + + template + explicit ReportService(HashSelector) : service_hash_(HashSelector::Result::value) { } + + typedef std::integral_constant OriginalHash; + typedef std::integral_constant NameHash; + + static google::protobuf::ServiceDescriptor const* descriptor(); + + // client methods -------------------------------------------------- + + void SendReport(::bgs::protocol::report::v1::SendReportRequest const* request, std::function responseCallback); + // server methods -------------------------------------------------- + + void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final; + + protected: + virtual uint32 HandleSendReport(::bgs::protocol::report::v1::SendReportRequest const* request, ::bgs::protocol::NoData* response); + + private: + uint32 service_hash_; + + GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ReportService); +}; + +// =================================================================== + + +// =================================================================== + +// Report + +// required string report_type = 1; +inline bool Report::has_report_type() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Report::set_has_report_type() { + _has_bits_[0] |= 0x00000001u; +} +inline void Report::clear_has_report_type() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Report::clear_report_type() { + if (report_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + report_type_->clear(); + } + clear_has_report_type(); +} +inline const ::std::string& Report::report_type() const { + // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.Report.report_type) + return *report_type_; +} +inline void Report::set_report_type(const ::std::string& value) { + set_has_report_type(); + if (report_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + report_type_ = new ::std::string; + } + report_type_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.report.v1.Report.report_type) +} +inline void Report::set_report_type(const char* value) { + set_has_report_type(); + if (report_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + report_type_ = new ::std::string; + } + report_type_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.report.v1.Report.report_type) +} +inline void Report::set_report_type(const char* value, size_t size) { + set_has_report_type(); + if (report_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + report_type_ = new ::std::string; + } + report_type_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.report.v1.Report.report_type) +} +inline ::std::string* Report::mutable_report_type() { + set_has_report_type(); + if (report_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + report_type_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.Report.report_type) + return report_type_; +} +inline ::std::string* Report::release_report_type() { + clear_has_report_type(); + if (report_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = report_type_; + report_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void Report::set_allocated_report_type(::std::string* report_type) { + if (report_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete report_type_; + } + if (report_type) { + set_has_report_type(); + report_type_ = report_type; + } else { + clear_has_report_type(); + report_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.Report.report_type) +} + +// repeated .bgs.protocol.Attribute attribute = 2; +inline int Report::attribute_size() const { + return attribute_.size(); +} +inline void Report::clear_attribute() { + attribute_.Clear(); +} +inline const ::bgs::protocol::Attribute& Report::attribute(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.Report.attribute) + return attribute_.Get(index); +} +inline ::bgs::protocol::Attribute* Report::mutable_attribute(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.Report.attribute) + return attribute_.Mutable(index); +} +inline ::bgs::protocol::Attribute* Report::add_attribute() { + // @@protoc_insertion_point(field_add:bgs.protocol.report.v1.Report.attribute) + return attribute_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& +Report::attribute() const { + // @@protoc_insertion_point(field_list:bgs.protocol.report.v1.Report.attribute) + return attribute_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* +Report::mutable_attribute() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.report.v1.Report.attribute) + return &attribute_; +} + +// optional int32 report_qos = 3 [default = 0]; +inline bool Report::has_report_qos() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void Report::set_has_report_qos() { + _has_bits_[0] |= 0x00000004u; +} +inline void Report::clear_has_report_qos() { + _has_bits_[0] &= ~0x00000004u; +} +inline void Report::clear_report_qos() { + report_qos_ = 0; + clear_has_report_qos(); +} +inline ::google::protobuf::int32 Report::report_qos() const { + // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.Report.report_qos) + return report_qos_; +} +inline void Report::set_report_qos(::google::protobuf::int32 value) { + set_has_report_qos(); + report_qos_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.report.v1.Report.report_qos) +} + +// optional .bgs.protocol.EntityId reporting_account = 4; +inline bool Report::has_reporting_account() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void Report::set_has_reporting_account() { + _has_bits_[0] |= 0x00000008u; +} +inline void Report::clear_has_reporting_account() { + _has_bits_[0] &= ~0x00000008u; +} +inline void Report::clear_reporting_account() { + if (reporting_account_ != NULL) reporting_account_->::bgs::protocol::EntityId::Clear(); + clear_has_reporting_account(); +} +inline const ::bgs::protocol::EntityId& Report::reporting_account() const { + // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.Report.reporting_account) + return reporting_account_ != NULL ? *reporting_account_ : *default_instance_->reporting_account_; +} +inline ::bgs::protocol::EntityId* Report::mutable_reporting_account() { + set_has_reporting_account(); + if (reporting_account_ == NULL) reporting_account_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.Report.reporting_account) + return reporting_account_; +} +inline ::bgs::protocol::EntityId* Report::release_reporting_account() { + clear_has_reporting_account(); + ::bgs::protocol::EntityId* temp = reporting_account_; + reporting_account_ = NULL; + return temp; +} +inline void Report::set_allocated_reporting_account(::bgs::protocol::EntityId* reporting_account) { + delete reporting_account_; + reporting_account_ = reporting_account; + if (reporting_account) { + set_has_reporting_account(); + } else { + clear_has_reporting_account(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.Report.reporting_account) +} + +// optional .bgs.protocol.EntityId reporting_game_account = 5; +inline bool Report::has_reporting_game_account() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void Report::set_has_reporting_game_account() { + _has_bits_[0] |= 0x00000010u; +} +inline void Report::clear_has_reporting_game_account() { + _has_bits_[0] &= ~0x00000010u; +} +inline void Report::clear_reporting_game_account() { + if (reporting_game_account_ != NULL) reporting_game_account_->::bgs::protocol::EntityId::Clear(); + clear_has_reporting_game_account(); +} +inline const ::bgs::protocol::EntityId& Report::reporting_game_account() const { + // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.Report.reporting_game_account) + return reporting_game_account_ != NULL ? *reporting_game_account_ : *default_instance_->reporting_game_account_; +} +inline ::bgs::protocol::EntityId* Report::mutable_reporting_game_account() { + set_has_reporting_game_account(); + if (reporting_game_account_ == NULL) reporting_game_account_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.Report.reporting_game_account) + return reporting_game_account_; +} +inline ::bgs::protocol::EntityId* Report::release_reporting_game_account() { + clear_has_reporting_game_account(); + ::bgs::protocol::EntityId* temp = reporting_game_account_; + reporting_game_account_ = NULL; + return temp; +} +inline void Report::set_allocated_reporting_game_account(::bgs::protocol::EntityId* reporting_game_account) { + delete reporting_game_account_; + reporting_game_account_ = reporting_game_account; + if (reporting_game_account) { + set_has_reporting_game_account(); + } else { + clear_has_reporting_game_account(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.Report.reporting_game_account) +} + +// optional fixed64 report_timestamp = 6; +inline bool Report::has_report_timestamp() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void Report::set_has_report_timestamp() { + _has_bits_[0] |= 0x00000020u; +} +inline void Report::clear_has_report_timestamp() { + _has_bits_[0] &= ~0x00000020u; +} +inline void Report::clear_report_timestamp() { + report_timestamp_ = GOOGLE_ULONGLONG(0); + clear_has_report_timestamp(); +} +inline ::google::protobuf::uint64 Report::report_timestamp() const { + // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.Report.report_timestamp) + return report_timestamp_; +} +inline void Report::set_report_timestamp(::google::protobuf::uint64 value) { + set_has_report_timestamp(); + report_timestamp_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.report.v1.Report.report_timestamp) +} + +// ------------------------------------------------------------------- + +// SendReportRequest + +// required .bgs.protocol.report.v1.Report report = 1; +inline bool SendReportRequest::has_report() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SendReportRequest::set_has_report() { + _has_bits_[0] |= 0x00000001u; +} +inline void SendReportRequest::clear_has_report() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SendReportRequest::clear_report() { + if (report_ != NULL) report_->::bgs::protocol::report::v1::Report::Clear(); + clear_has_report(); +} +inline const ::bgs::protocol::report::v1::Report& SendReportRequest::report() const { + // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.SendReportRequest.report) + return report_ != NULL ? *report_ : *default_instance_->report_; +} +inline ::bgs::protocol::report::v1::Report* SendReportRequest::mutable_report() { + set_has_report(); + if (report_ == NULL) report_ = new ::bgs::protocol::report::v1::Report; + // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.SendReportRequest.report) + return report_; +} +inline ::bgs::protocol::report::v1::Report* SendReportRequest::release_report() { + clear_has_report(); + ::bgs::protocol::report::v1::Report* temp = report_; + report_ = NULL; + return temp; +} +inline void SendReportRequest::set_allocated_report(::bgs::protocol::report::v1::Report* report) { + delete report_; + report_ = report; + if (report) { + set_has_report(); + } else { + clear_has_report(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.SendReportRequest.report) +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace report +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_report_5fservice_2eproto__INCLUDED diff --git a/src/server/proto/Client/resource_service.pb.cc b/src/server/proto/Client/resource_service.pb.cc new file mode 100644 index 00000000000..d3b5466487f --- /dev/null +++ b/src/server/proto/Client/resource_service.pb.cc @@ -0,0 +1,489 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: resource_service.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "resource_service.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +#include "BattlenetRpcErrorCodes.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { +namespace resources { +namespace v1 { + +namespace { + +const ::google::protobuf::Descriptor* ContentHandleRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ContentHandleRequest_reflection_ = NULL; +const ::google::protobuf::ServiceDescriptor* ResourcesService_descriptor_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_resource_5fservice_2eproto() { + protobuf_AddDesc_resource_5fservice_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "resource_service.proto"); + GOOGLE_CHECK(file != NULL); + ContentHandleRequest_descriptor_ = file->message_type(0); + static const int ContentHandleRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentHandleRequest, program_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentHandleRequest, stream_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentHandleRequest, version_), + }; + ContentHandleRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ContentHandleRequest_descriptor_, + ContentHandleRequest::default_instance_, + ContentHandleRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentHandleRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentHandleRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ContentHandleRequest)); + ResourcesService_descriptor_ = file->service(0); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_resource_5fservice_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ContentHandleRequest_descriptor_, &ContentHandleRequest::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_resource_5fservice_2eproto() { + delete ContentHandleRequest::default_instance_; + delete ContentHandleRequest_reflection_; +} + +void protobuf_AddDesc_resource_5fservice_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::bgs::protocol::protobuf_AddDesc_content_5fhandle_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\026resource_service.proto\022\031bgs.protocol.r" + "esources.v1\032\032content_handle_types.proto\032" + "\017rpc_types.proto\"T\n\024ContentHandleRequest" + "\022\017\n\007program\030\001 \002(\007\022\016\n\006stream\030\002 \002(\007\022\033\n\007ver" + "sion\030\003 \001(\007:\n17017296192\240\001\n\020ResourcesServ" + "ice\022f\n\020GetContentHandle\022/.bgs.protocol.r" + "esources.v1.ContentHandleRequest\032\033.bgs.p" + "rotocol.ContentHandle\"\004\200\265\030\001\032$\312>!bnet.pro" + "tocol.resources.ResourcesB\005H\001\200\001\000", 352); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "resource_service.proto", &protobuf_RegisterTypes); + ContentHandleRequest::default_instance_ = new ContentHandleRequest(); + ContentHandleRequest::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_resource_5fservice_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_resource_5fservice_2eproto { + StaticDescriptorInitializer_resource_5fservice_2eproto() { + protobuf_AddDesc_resource_5fservice_2eproto(); + } +} static_descriptor_initializer_resource_5fservice_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int ContentHandleRequest::kProgramFieldNumber; +const int ContentHandleRequest::kStreamFieldNumber; +const int ContentHandleRequest::kVersionFieldNumber; +#endif // !_MSC_VER + +ContentHandleRequest::ContentHandleRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.resources.v1.ContentHandleRequest) +} + +void ContentHandleRequest::InitAsDefaultInstance() { +} + +ContentHandleRequest::ContentHandleRequest(const ContentHandleRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.resources.v1.ContentHandleRequest) +} + +void ContentHandleRequest::SharedCtor() { + _cached_size_ = 0; + program_ = 0u; + stream_ = 0u; + version_ = 1701729619u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ContentHandleRequest::~ContentHandleRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.resources.v1.ContentHandleRequest) + SharedDtor(); +} + +void ContentHandleRequest::SharedDtor() { + if (this != default_instance_) { + } +} + +void ContentHandleRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ContentHandleRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ContentHandleRequest_descriptor_; +} + +const ContentHandleRequest& ContentHandleRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_resource_5fservice_2eproto(); + return *default_instance_; +} + +ContentHandleRequest* ContentHandleRequest::default_instance_ = NULL; + +ContentHandleRequest* ContentHandleRequest::New() const { + return new ContentHandleRequest; +} + +void ContentHandleRequest::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(program_, stream_); + version_ = 1701729619u; + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ContentHandleRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.resources.v1.ContentHandleRequest) + 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)) { + // required fixed32 program = 1; + case 1: { + if (tag == 13) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &program_))); + set_has_program(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(21)) goto parse_stream; + break; + } + + // required fixed32 stream = 2; + case 2: { + if (tag == 21) { + parse_stream: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &stream_))); + set_has_stream(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(29)) goto parse_version; + break; + } + + // optional fixed32 version = 3 [default = 1701729619]; + case 3: { + if (tag == 29) { + parse_version: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + 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:bgs.protocol.resources.v1.ContentHandleRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.resources.v1.ContentHandleRequest) + return false; +#undef DO_ +} + +void ContentHandleRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.resources.v1.ContentHandleRequest) + // required fixed32 program = 1; + if (has_program()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->program(), output); + } + + // required fixed32 stream = 2; + if (has_stream()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->stream(), output); + } + + // optional fixed32 version = 3 [default = 1701729619]; + if (has_version()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->version(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.resources.v1.ContentHandleRequest) +} + +::google::protobuf::uint8* ContentHandleRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.resources.v1.ContentHandleRequest) + // required fixed32 program = 1; + if (has_program()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->program(), target); + } + + // required fixed32 stream = 2; + if (has_stream()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->stream(), target); + } + + // optional fixed32 version = 3 [default = 1701729619]; + if (has_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->version(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.resources.v1.ContentHandleRequest) + return target; +} + +int ContentHandleRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed32 program = 1; + if (has_program()) { + total_size += 1 + 4; + } + + // required fixed32 stream = 2; + if (has_stream()) { + total_size += 1 + 4; + } + + // optional fixed32 version = 3 [default = 1701729619]; + if (has_version()) { + 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 ContentHandleRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ContentHandleRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ContentHandleRequest::MergeFrom(const ContentHandleRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_program()) { + set_program(from.program()); + } + if (from.has_stream()) { + set_stream(from.stream()); + } + if (from.has_version()) { + set_version(from.version()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ContentHandleRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ContentHandleRequest::CopyFrom(const ContentHandleRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ContentHandleRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void ContentHandleRequest::Swap(ContentHandleRequest* other) { + if (other != this) { + std::swap(program_, other->program_); + std::swap(stream_, other->stream_); + 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 ContentHandleRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ContentHandleRequest_descriptor_; + metadata.reflection = ContentHandleRequest_reflection_; + return metadata; +} + + +// =================================================================== + +google::protobuf::ServiceDescriptor const* ResourcesService::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ResourcesService_descriptor_; +} + +void ResourcesService::GetContentHandle(::bgs::protocol::resources::v1::ContentHandleRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method ResourcesService.GetContentHandle(bgs.protocol.resources.v1.ContentHandleRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 1, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::ContentHandle response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void ResourcesService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) { + switch(methodId) { + case 1: { + ::bgs::protocol::resources::v1::ContentHandleRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ResourcesService.GetContentHandle server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::ContentHandle response; + uint32 status = HandleGetContentHandle(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method ResourcesService.GetContentHandle(bgs.protocol.resources.v1.ContentHandleRequest{ %s }) returned bgs.protocol.ContentHandle{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 1, token, &response); + else + SendResponse(service_hash_, 1, token, status); + break; + } + default: + TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId); + SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD); + break; + } +} + +uint32 ResourcesService::HandleGetContentHandle(::bgs::protocol::resources::v1::ContentHandleRequest const* request, ::bgs::protocol::ContentHandle* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ResourcesService.GetContentHandle({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace resources +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/resource_service.pb.h b/src/server/proto/Client/resource_service.pb.h new file mode 100644 index 00000000000..8d8613a9ea2 --- /dev/null +++ b/src/server/proto/Client/resource_service.pb.h @@ -0,0 +1,274 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: resource_service.proto + +#ifndef PROTOBUF_resource_5fservice_2eproto__INCLUDED +#define PROTOBUF_resource_5fservice_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include "content_handle_types.pb.h" +#include "rpc_types.pb.h" +#include "ServiceBase.h" +#include "MessageBuffer.h" +#include +#include +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { +namespace resources { +namespace v1 { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_resource_5fservice_2eproto(); +void protobuf_AssignDesc_resource_5fservice_2eproto(); +void protobuf_ShutdownFile_resource_5fservice_2eproto(); + +class ContentHandleRequest; + +// =================================================================== + +class TC_SHARED_API ContentHandleRequest : public ::google::protobuf::Message { + public: + ContentHandleRequest(); + virtual ~ContentHandleRequest(); + + ContentHandleRequest(const ContentHandleRequest& from); + + inline ContentHandleRequest& operator=(const ContentHandleRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ContentHandleRequest& default_instance(); + + void Swap(ContentHandleRequest* other); + + // implements Message ---------------------------------------------- + + ContentHandleRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ContentHandleRequest& from); + void MergeFrom(const ContentHandleRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed32 program = 1; + inline bool has_program() const; + inline void clear_program(); + static const int kProgramFieldNumber = 1; + inline ::google::protobuf::uint32 program() const; + inline void set_program(::google::protobuf::uint32 value); + + // required fixed32 stream = 2; + inline bool has_stream() const; + inline void clear_stream(); + static const int kStreamFieldNumber = 2; + inline ::google::protobuf::uint32 stream() const; + inline void set_stream(::google::protobuf::uint32 value); + + // optional fixed32 version = 3 [default = 1701729619]; + inline bool has_version() const; + inline void clear_version(); + static const int kVersionFieldNumber = 3; + inline ::google::protobuf::uint32 version() const; + inline void set_version(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.resources.v1.ContentHandleRequest) + private: + inline void set_has_program(); + inline void clear_has_program(); + inline void set_has_stream(); + inline void clear_has_stream(); + inline void set_has_version(); + inline void clear_has_version(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 program_; + ::google::protobuf::uint32 stream_; + ::google::protobuf::uint32 version_; + friend void TC_SHARED_API protobuf_AddDesc_resource_5fservice_2eproto(); + friend void protobuf_AssignDesc_resource_5fservice_2eproto(); + friend void protobuf_ShutdownFile_resource_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ContentHandleRequest* default_instance_; +}; +// =================================================================== + +class TC_SHARED_API ResourcesService : public ServiceBase +{ + public: + + template + explicit ResourcesService(HashSelector) : service_hash_(HashSelector::Result::value) { } + + typedef std::integral_constant OriginalHash; + typedef std::integral_constant NameHash; + + static google::protobuf::ServiceDescriptor const* descriptor(); + + // client methods -------------------------------------------------- + + void GetContentHandle(::bgs::protocol::resources::v1::ContentHandleRequest const* request, std::function responseCallback); + // server methods -------------------------------------------------- + + void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final; + + protected: + virtual uint32 HandleGetContentHandle(::bgs::protocol::resources::v1::ContentHandleRequest const* request, ::bgs::protocol::ContentHandle* response); + + private: + uint32 service_hash_; + + GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ResourcesService); +}; + +// =================================================================== + + +// =================================================================== + +// ContentHandleRequest + +// required fixed32 program = 1; +inline bool ContentHandleRequest::has_program() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ContentHandleRequest::set_has_program() { + _has_bits_[0] |= 0x00000001u; +} +inline void ContentHandleRequest::clear_has_program() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ContentHandleRequest::clear_program() { + program_ = 0u; + clear_has_program(); +} +inline ::google::protobuf::uint32 ContentHandleRequest::program() const { + // @@protoc_insertion_point(field_get:bgs.protocol.resources.v1.ContentHandleRequest.program) + return program_; +} +inline void ContentHandleRequest::set_program(::google::protobuf::uint32 value) { + set_has_program(); + program_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.resources.v1.ContentHandleRequest.program) +} + +// required fixed32 stream = 2; +inline bool ContentHandleRequest::has_stream() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ContentHandleRequest::set_has_stream() { + _has_bits_[0] |= 0x00000002u; +} +inline void ContentHandleRequest::clear_has_stream() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ContentHandleRequest::clear_stream() { + stream_ = 0u; + clear_has_stream(); +} +inline ::google::protobuf::uint32 ContentHandleRequest::stream() const { + // @@protoc_insertion_point(field_get:bgs.protocol.resources.v1.ContentHandleRequest.stream) + return stream_; +} +inline void ContentHandleRequest::set_stream(::google::protobuf::uint32 value) { + set_has_stream(); + stream_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.resources.v1.ContentHandleRequest.stream) +} + +// optional fixed32 version = 3 [default = 1701729619]; +inline bool ContentHandleRequest::has_version() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ContentHandleRequest::set_has_version() { + _has_bits_[0] |= 0x00000004u; +} +inline void ContentHandleRequest::clear_has_version() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ContentHandleRequest::clear_version() { + version_ = 1701729619u; + clear_has_version(); +} +inline ::google::protobuf::uint32 ContentHandleRequest::version() const { + // @@protoc_insertion_point(field_get:bgs.protocol.resources.v1.ContentHandleRequest.version) + return version_; +} +inline void ContentHandleRequest::set_version(::google::protobuf::uint32 value) { + set_has_version(); + version_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.resources.v1.ContentHandleRequest.version) +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace resources +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_resource_5fservice_2eproto__INCLUDED diff --git a/src/server/proto/Client/role_types.pb.cc b/src/server/proto/Client/role_types.pb.cc new file mode 100644 index 00000000000..73bc233b876 --- /dev/null +++ b/src/server/proto/Client/role_types.pb.cc @@ -0,0 +1,815 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: role_types.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "role_types.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { + +namespace { + +const ::google::protobuf::Descriptor* Role_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Role_reflection_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_role_5ftypes_2eproto() { + protobuf_AddDesc_role_5ftypes_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "role_types.proto"); + GOOGLE_CHECK(file != NULL); + Role_descriptor_ = file->message_type(0); + static const int Role_offsets_[10] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, privilege_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, assignable_role_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, required_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, unique_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, relegation_role_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, attribute_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, kickable_role_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, removable_role_), + }; + Role_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Role_descriptor_, + Role::default_instance_, + Role_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Role)); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_role_5ftypes_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Role_descriptor_, &Role::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_role_5ftypes_2eproto() { + delete Role::default_instance_; + delete Role_reflection_; +} + +void protobuf_AddDesc_role_5ftypes_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\020role_types.proto\022\014bgs.protocol\032\025attrib" + "ute_types.proto\"\374\001\n\004Role\022\n\n\002id\030\001 \002(\r\022\014\n\004" + "name\030\002 \002(\t\022\021\n\tprivilege\030\003 \003(\t\022\033\n\017assigna" + "ble_role\030\004 \003(\rB\002\020\001\022\027\n\010required\030\005 \001(\010:\005fa" + "lse\022\025\n\006unique\030\006 \001(\010:\005false\022\027\n\017relegation" + "_role\030\007 \001(\r\022*\n\tattribute\030\010 \003(\0132\027.bgs.pro" + "tocol.Attribute\022\031\n\rkickable_role\030\t \003(\rB\002" + "\020\001\022\032\n\016removable_role\030\n \003(\rB\002\020\001B\002H\001", 314); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "role_types.proto", &protobuf_RegisterTypes); + Role::default_instance_ = new Role(); + Role::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_role_5ftypes_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_role_5ftypes_2eproto { + StaticDescriptorInitializer_role_5ftypes_2eproto() { + protobuf_AddDesc_role_5ftypes_2eproto(); + } +} static_descriptor_initializer_role_5ftypes_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int Role::kIdFieldNumber; +const int Role::kNameFieldNumber; +const int Role::kPrivilegeFieldNumber; +const int Role::kAssignableRoleFieldNumber; +const int Role::kRequiredFieldNumber; +const int Role::kUniqueFieldNumber; +const int Role::kRelegationRoleFieldNumber; +const int Role::kAttributeFieldNumber; +const int Role::kKickableRoleFieldNumber; +const int Role::kRemovableRoleFieldNumber; +#endif // !_MSC_VER + +Role::Role() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.Role) +} + +void Role::InitAsDefaultInstance() { +} + +Role::Role(const Role& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.Role) +} + +void Role::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + id_ = 0u; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + required_ = false; + unique_ = false; + relegation_role_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Role::~Role() { + // @@protoc_insertion_point(destructor:bgs.protocol.Role) + SharedDtor(); +} + +void Role::SharedDtor() { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete name_; + } + if (this != default_instance_) { + } +} + +void Role::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Role::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Role_descriptor_; +} + +const Role& Role::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_role_5ftypes_2eproto(); + return *default_instance_; +} + +Role* Role::default_instance_ = NULL; + +Role* Role::New() const { + return new Role; +} + +void Role::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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] & 115) { + ZR_(id_, unique_); + if (has_name()) { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_->clear(); + } + } + relegation_role_ = 0u; + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + privilege_.Clear(); + assignable_role_.Clear(); + attribute_.Clear(); + kickable_role_.Clear(); + removable_role_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Role::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.Role) + 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)) { + // required uint32 id = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &id_))); + set_has_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_name; + break; + } + + // required 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_privilege; + break; + } + + // repeated string privilege = 3; + case 3: { + if (tag == 26) { + parse_privilege: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_privilege())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->privilege(this->privilege_size() - 1).data(), + this->privilege(this->privilege_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE, + "privilege"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_privilege; + if (input->ExpectTag(34)) goto parse_assignable_role; + break; + } + + // repeated uint32 assignable_role = 4 [packed = true]; + case 4: { + if (tag == 34) { + parse_assignable_role: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_assignable_role()))); + } else if (tag == 32) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 34, input, this->mutable_assignable_role()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_required; + break; + } + + // optional bool required = 5 [default = false]; + case 5: { + if (tag == 40) { + parse_required: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &required_))); + set_has_required(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_unique; + break; + } + + // optional bool unique = 6 [default = false]; + case 6: { + if (tag == 48) { + parse_unique: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &unique_))); + set_has_unique(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(56)) goto parse_relegation_role; + break; + } + + // optional uint32 relegation_role = 7; + case 7: { + if (tag == 56) { + parse_relegation_role: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &relegation_role_))); + set_has_relegation_role(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(66)) goto parse_attribute; + break; + } + + // repeated .bgs.protocol.Attribute attribute = 8; + case 8: { + if (tag == 66) { + parse_attribute: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_attribute())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(66)) goto parse_attribute; + if (input->ExpectTag(74)) goto parse_kickable_role; + break; + } + + // repeated uint32 kickable_role = 9 [packed = true]; + case 9: { + if (tag == 74) { + parse_kickable_role: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_kickable_role()))); + } else if (tag == 72) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 74, input, this->mutable_kickable_role()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(82)) goto parse_removable_role; + break; + } + + // repeated uint32 removable_role = 10 [packed = true]; + case 10: { + if (tag == 82) { + parse_removable_role: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_removable_role()))); + } else if (tag == 80) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 82, input, this->mutable_removable_role()))); + } 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:bgs.protocol.Role) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.Role) + return false; +#undef DO_ +} + +void Role::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.Role) + // required uint32 id = 1; + if (has_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->id(), output); + } + + // required 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 string privilege = 3; + for (int i = 0; i < this->privilege_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->privilege(i).data(), this->privilege(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "privilege"); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->privilege(i), output); + } + + // repeated uint32 assignable_role = 4 [packed = true]; + if (this->assignable_role_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(4, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_assignable_role_cached_byte_size_); + } + for (int i = 0; i < this->assignable_role_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag( + this->assignable_role(i), output); + } + + // optional bool required = 5 [default = false]; + if (has_required()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->required(), output); + } + + // optional bool unique = 6 [default = false]; + if (has_unique()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->unique(), output); + } + + // optional uint32 relegation_role = 7; + if (has_relegation_role()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->relegation_role(), output); + } + + // repeated .bgs.protocol.Attribute attribute = 8; + for (int i = 0; i < this->attribute_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 8, this->attribute(i), output); + } + + // repeated uint32 kickable_role = 9 [packed = true]; + if (this->kickable_role_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(9, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_kickable_role_cached_byte_size_); + } + for (int i = 0; i < this->kickable_role_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag( + this->kickable_role(i), output); + } + + // repeated uint32 removable_role = 10 [packed = true]; + if (this->removable_role_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(10, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_removable_role_cached_byte_size_); + } + for (int i = 0; i < this->removable_role_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag( + this->removable_role(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.Role) +} + +::google::protobuf::uint8* Role::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.Role) + // required uint32 id = 1; + if (has_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->id(), target); + } + + // required 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 string privilege = 3; + for (int i = 0; i < this->privilege_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->privilege(i).data(), this->privilege(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "privilege"); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(3, this->privilege(i), target); + } + + // repeated uint32 assignable_role = 4 [packed = true]; + if (this->assignable_role_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 4, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _assignable_role_cached_byte_size_, target); + } + for (int i = 0; i < this->assignable_role_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32NoTagToArray(this->assignable_role(i), target); + } + + // optional bool required = 5 [default = false]; + if (has_required()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->required(), target); + } + + // optional bool unique = 6 [default = false]; + if (has_unique()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->unique(), target); + } + + // optional uint32 relegation_role = 7; + if (has_relegation_role()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->relegation_role(), target); + } + + // repeated .bgs.protocol.Attribute attribute = 8; + for (int i = 0; i < this->attribute_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 8, this->attribute(i), target); + } + + // repeated uint32 kickable_role = 9 [packed = true]; + if (this->kickable_role_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 9, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _kickable_role_cached_byte_size_, target); + } + for (int i = 0; i < this->kickable_role_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32NoTagToArray(this->kickable_role(i), target); + } + + // repeated uint32 removable_role = 10 [packed = true]; + if (this->removable_role_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 10, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _removable_role_cached_byte_size_, target); + } + for (int i = 0; i < this->removable_role_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32NoTagToArray(this->removable_role(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.Role) + return target; +} + +int Role::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required uint32 id = 1; + if (has_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->id()); + } + + // required string name = 2; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // optional bool required = 5 [default = false]; + if (has_required()) { + total_size += 1 + 1; + } + + // optional bool unique = 6 [default = false]; + if (has_unique()) { + total_size += 1 + 1; + } + + // optional uint32 relegation_role = 7; + if (has_relegation_role()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->relegation_role()); + } + + } + // repeated string privilege = 3; + total_size += 1 * this->privilege_size(); + for (int i = 0; i < this->privilege_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->privilege(i)); + } + + // repeated uint32 assignable_role = 4 [packed = true]; + { + int data_size = 0; + for (int i = 0; i < this->assignable_role_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->assignable_role(i)); + } + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _assignable_role_cached_byte_size_ = data_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + // repeated .bgs.protocol.Attribute attribute = 8; + total_size += 1 * this->attribute_size(); + for (int i = 0; i < this->attribute_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->attribute(i)); + } + + // repeated uint32 kickable_role = 9 [packed = true]; + { + int data_size = 0; + for (int i = 0; i < this->kickable_role_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->kickable_role(i)); + } + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _kickable_role_cached_byte_size_ = data_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + // repeated uint32 removable_role = 10 [packed = true]; + { + int data_size = 0; + for (int i = 0; i < this->removable_role_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->removable_role(i)); + } + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _removable_role_cached_byte_size_ = data_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_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 Role::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Role* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Role::MergeFrom(const Role& from) { + GOOGLE_CHECK_NE(&from, this); + privilege_.MergeFrom(from.privilege_); + assignable_role_.MergeFrom(from.assignable_role_); + attribute_.MergeFrom(from.attribute_); + kickable_role_.MergeFrom(from.kickable_role_); + removable_role_.MergeFrom(from.removable_role_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_id()) { + set_id(from.id()); + } + if (from.has_name()) { + set_name(from.name()); + } + if (from.has_required()) { + set_required(from.required()); + } + if (from.has_unique()) { + set_unique(from.unique()); + } + if (from.has_relegation_role()) { + set_relegation_role(from.relegation_role()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Role::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Role::CopyFrom(const Role& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Role::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false; + return true; +} + +void Role::Swap(Role* other) { + if (other != this) { + std::swap(id_, other->id_); + std::swap(name_, other->name_); + privilege_.Swap(&other->privilege_); + assignable_role_.Swap(&other->assignable_role_); + std::swap(required_, other->required_); + std::swap(unique_, other->unique_); + std::swap(relegation_role_, other->relegation_role_); + attribute_.Swap(&other->attribute_); + kickable_role_.Swap(&other->kickable_role_); + removable_role_.Swap(&other->removable_role_); + 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 Role::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Role_descriptor_; + metadata.reflection = Role_reflection_; + return metadata; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/role_types.pb.h b/src/server/proto/Client/role_types.pb.h new file mode 100644 index 00000000000..33abb25e127 --- /dev/null +++ b/src/server/proto/Client/role_types.pb.h @@ -0,0 +1,610 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: role_types.proto + +#ifndef PROTOBUF_role_5ftypes_2eproto__INCLUDED +#define PROTOBUF_role_5ftypes_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include "attribute_types.pb.h" +#include "Define.h" // for TRINITY_SHARED_API +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_role_5ftypes_2eproto(); +void protobuf_AssignDesc_role_5ftypes_2eproto(); +void protobuf_ShutdownFile_role_5ftypes_2eproto(); + +class Role; + +// =================================================================== + +class TC_SHARED_API Role : public ::google::protobuf::Message { + public: + Role(); + virtual ~Role(); + + Role(const Role& from); + + inline Role& operator=(const Role& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Role& default_instance(); + + void Swap(Role* other); + + // implements Message ---------------------------------------------- + + Role* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Role& from); + void MergeFrom(const Role& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required uint32 id = 1; + inline bool has_id() const; + inline void clear_id(); + static const int kIdFieldNumber = 1; + inline ::google::protobuf::uint32 id() const; + inline void set_id(::google::protobuf::uint32 value); + + // required string name = 2; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 2; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + inline ::std::string* release_name(); + inline void set_allocated_name(::std::string* name); + + // repeated string privilege = 3; + inline int privilege_size() const; + inline void clear_privilege(); + static const int kPrivilegeFieldNumber = 3; + inline const ::std::string& privilege(int index) const; + inline ::std::string* mutable_privilege(int index); + inline void set_privilege(int index, const ::std::string& value); + inline void set_privilege(int index, const char* value); + inline void set_privilege(int index, const char* value, size_t size); + inline ::std::string* add_privilege(); + inline void add_privilege(const ::std::string& value); + inline void add_privilege(const char* value); + inline void add_privilege(const char* value, size_t size); + inline const ::google::protobuf::RepeatedPtrField< ::std::string>& privilege() const; + inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_privilege(); + + // repeated uint32 assignable_role = 4 [packed = true]; + inline int assignable_role_size() const; + inline void clear_assignable_role(); + static const int kAssignableRoleFieldNumber = 4; + inline ::google::protobuf::uint32 assignable_role(int index) const; + inline void set_assignable_role(int index, ::google::protobuf::uint32 value); + inline void add_assignable_role(::google::protobuf::uint32 value); + inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + assignable_role() const; + inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_assignable_role(); + + // optional bool required = 5 [default = false]; + inline bool has_required() const; + inline void clear_required(); + static const int kRequiredFieldNumber = 5; + inline bool required() const; + inline void set_required(bool value); + + // optional bool unique = 6 [default = false]; + inline bool has_unique() const; + inline void clear_unique(); + static const int kUniqueFieldNumber = 6; + inline bool unique() const; + inline void set_unique(bool value); + + // optional uint32 relegation_role = 7; + inline bool has_relegation_role() const; + inline void clear_relegation_role(); + static const int kRelegationRoleFieldNumber = 7; + inline ::google::protobuf::uint32 relegation_role() const; + inline void set_relegation_role(::google::protobuf::uint32 value); + + // repeated .bgs.protocol.Attribute attribute = 8; + inline int attribute_size() const; + inline void clear_attribute(); + static const int kAttributeFieldNumber = 8; + inline const ::bgs::protocol::Attribute& attribute(int index) const; + inline ::bgs::protocol::Attribute* mutable_attribute(int index); + inline ::bgs::protocol::Attribute* add_attribute(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& + attribute() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* + mutable_attribute(); + + // repeated uint32 kickable_role = 9 [packed = true]; + inline int kickable_role_size() const; + inline void clear_kickable_role(); + static const int kKickableRoleFieldNumber = 9; + inline ::google::protobuf::uint32 kickable_role(int index) const; + inline void set_kickable_role(int index, ::google::protobuf::uint32 value); + inline void add_kickable_role(::google::protobuf::uint32 value); + inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + kickable_role() const; + inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_kickable_role(); + + // repeated uint32 removable_role = 10 [packed = true]; + inline int removable_role_size() const; + inline void clear_removable_role(); + static const int kRemovableRoleFieldNumber = 10; + inline ::google::protobuf::uint32 removable_role(int index) const; + inline void set_removable_role(int index, ::google::protobuf::uint32 value); + inline void add_removable_role(::google::protobuf::uint32 value); + inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + removable_role() const; + inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_removable_role(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.Role) + private: + inline void set_has_id(); + inline void clear_has_id(); + inline void set_has_name(); + inline void clear_has_name(); + inline void set_has_required(); + inline void clear_has_required(); + inline void set_has_unique(); + inline void clear_has_unique(); + inline void set_has_relegation_role(); + inline void clear_has_relegation_role(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* name_; + ::google::protobuf::RepeatedPtrField< ::std::string> privilege_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > assignable_role_; + mutable int _assignable_role_cached_byte_size_; + ::google::protobuf::uint32 id_; + bool required_; + bool unique_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > kickable_role_; + mutable int _kickable_role_cached_byte_size_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > removable_role_; + mutable int _removable_role_cached_byte_size_; + ::google::protobuf::uint32 relegation_role_; + friend void TC_SHARED_API protobuf_AddDesc_role_5ftypes_2eproto(); + friend void protobuf_AssignDesc_role_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_role_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static Role* default_instance_; +}; +// =================================================================== + + +// =================================================================== + + +// =================================================================== + +// Role + +// required uint32 id = 1; +inline bool Role::has_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Role::set_has_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void Role::clear_has_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Role::clear_id() { + id_ = 0u; + clear_has_id(); +} +inline ::google::protobuf::uint32 Role::id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Role.id) + return id_; +} +inline void Role::set_id(::google::protobuf::uint32 value) { + set_has_id(); + id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.Role.id) +} + +// required string name = 2; +inline bool Role::has_name() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Role::set_has_name() { + _has_bits_[0] |= 0x00000002u; +} +inline void Role::clear_has_name() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Role::clear_name() { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& Role::name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Role.name) + return *name_; +} +inline void Role::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.Role.name) +} +inline void Role::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.Role.name) +} +inline void Role::set_name(const char* value, size_t size) { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.Role.name) +} +inline ::std::string* Role::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.Role.name) + return name_; +} +inline ::std::string* Role::release_name() { + clear_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = name_; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void Role::set_allocated_name(::std::string* name) { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete name_; + } + if (name) { + set_has_name(); + name_ = name; + } else { + clear_has_name(); + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Role.name) +} + +// repeated string privilege = 3; +inline int Role::privilege_size() const { + return privilege_.size(); +} +inline void Role::clear_privilege() { + privilege_.Clear(); +} +inline const ::std::string& Role::privilege(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.Role.privilege) + return privilege_.Get(index); +} +inline ::std::string* Role::mutable_privilege(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.Role.privilege) + return privilege_.Mutable(index); +} +inline void Role::set_privilege(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:bgs.protocol.Role.privilege) + privilege_.Mutable(index)->assign(value); +} +inline void Role::set_privilege(int index, const char* value) { + privilege_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.Role.privilege) +} +inline void Role::set_privilege(int index, const char* value, size_t size) { + privilege_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.Role.privilege) +} +inline ::std::string* Role::add_privilege() { + return privilege_.Add(); +} +inline void Role::add_privilege(const ::std::string& value) { + privilege_.Add()->assign(value); + // @@protoc_insertion_point(field_add:bgs.protocol.Role.privilege) +} +inline void Role::add_privilege(const char* value) { + privilege_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:bgs.protocol.Role.privilege) +} +inline void Role::add_privilege(const char* value, size_t size) { + privilege_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:bgs.protocol.Role.privilege) +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +Role::privilege() const { + // @@protoc_insertion_point(field_list:bgs.protocol.Role.privilege) + return privilege_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +Role::mutable_privilege() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.Role.privilege) + return &privilege_; +} + +// repeated uint32 assignable_role = 4 [packed = true]; +inline int Role::assignable_role_size() const { + return assignable_role_.size(); +} +inline void Role::clear_assignable_role() { + assignable_role_.Clear(); +} +inline ::google::protobuf::uint32 Role::assignable_role(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.Role.assignable_role) + return assignable_role_.Get(index); +} +inline void Role::set_assignable_role(int index, ::google::protobuf::uint32 value) { + assignable_role_.Set(index, value); + // @@protoc_insertion_point(field_set:bgs.protocol.Role.assignable_role) +} +inline void Role::add_assignable_role(::google::protobuf::uint32 value) { + assignable_role_.Add(value); + // @@protoc_insertion_point(field_add:bgs.protocol.Role.assignable_role) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +Role::assignable_role() const { + // @@protoc_insertion_point(field_list:bgs.protocol.Role.assignable_role) + return assignable_role_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +Role::mutable_assignable_role() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.Role.assignable_role) + return &assignable_role_; +} + +// optional bool required = 5 [default = false]; +inline bool Role::has_required() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void Role::set_has_required() { + _has_bits_[0] |= 0x00000010u; +} +inline void Role::clear_has_required() { + _has_bits_[0] &= ~0x00000010u; +} +inline void Role::clear_required() { + required_ = false; + clear_has_required(); +} +inline bool Role::required() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Role.required) + return required_; +} +inline void Role::set_required(bool value) { + set_has_required(); + required_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.Role.required) +} + +// optional bool unique = 6 [default = false]; +inline bool Role::has_unique() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void Role::set_has_unique() { + _has_bits_[0] |= 0x00000020u; +} +inline void Role::clear_has_unique() { + _has_bits_[0] &= ~0x00000020u; +} +inline void Role::clear_unique() { + unique_ = false; + clear_has_unique(); +} +inline bool Role::unique() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Role.unique) + return unique_; +} +inline void Role::set_unique(bool value) { + set_has_unique(); + unique_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.Role.unique) +} + +// optional uint32 relegation_role = 7; +inline bool Role::has_relegation_role() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void Role::set_has_relegation_role() { + _has_bits_[0] |= 0x00000040u; +} +inline void Role::clear_has_relegation_role() { + _has_bits_[0] &= ~0x00000040u; +} +inline void Role::clear_relegation_role() { + relegation_role_ = 0u; + clear_has_relegation_role(); +} +inline ::google::protobuf::uint32 Role::relegation_role() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Role.relegation_role) + return relegation_role_; +} +inline void Role::set_relegation_role(::google::protobuf::uint32 value) { + set_has_relegation_role(); + relegation_role_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.Role.relegation_role) +} + +// repeated .bgs.protocol.Attribute attribute = 8; +inline int Role::attribute_size() const { + return attribute_.size(); +} +inline void Role::clear_attribute() { + attribute_.Clear(); +} +inline const ::bgs::protocol::Attribute& Role::attribute(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.Role.attribute) + return attribute_.Get(index); +} +inline ::bgs::protocol::Attribute* Role::mutable_attribute(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.Role.attribute) + return attribute_.Mutable(index); +} +inline ::bgs::protocol::Attribute* Role::add_attribute() { + // @@protoc_insertion_point(field_add:bgs.protocol.Role.attribute) + return attribute_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& +Role::attribute() const { + // @@protoc_insertion_point(field_list:bgs.protocol.Role.attribute) + return attribute_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* +Role::mutable_attribute() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.Role.attribute) + return &attribute_; +} + +// repeated uint32 kickable_role = 9 [packed = true]; +inline int Role::kickable_role_size() const { + return kickable_role_.size(); +} +inline void Role::clear_kickable_role() { + kickable_role_.Clear(); +} +inline ::google::protobuf::uint32 Role::kickable_role(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.Role.kickable_role) + return kickable_role_.Get(index); +} +inline void Role::set_kickable_role(int index, ::google::protobuf::uint32 value) { + kickable_role_.Set(index, value); + // @@protoc_insertion_point(field_set:bgs.protocol.Role.kickable_role) +} +inline void Role::add_kickable_role(::google::protobuf::uint32 value) { + kickable_role_.Add(value); + // @@protoc_insertion_point(field_add:bgs.protocol.Role.kickable_role) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +Role::kickable_role() const { + // @@protoc_insertion_point(field_list:bgs.protocol.Role.kickable_role) + return kickable_role_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +Role::mutable_kickable_role() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.Role.kickable_role) + return &kickable_role_; +} + +// repeated uint32 removable_role = 10 [packed = true]; +inline int Role::removable_role_size() const { + return removable_role_.size(); +} +inline void Role::clear_removable_role() { + removable_role_.Clear(); +} +inline ::google::protobuf::uint32 Role::removable_role(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.Role.removable_role) + return removable_role_.Get(index); +} +inline void Role::set_removable_role(int index, ::google::protobuf::uint32 value) { + removable_role_.Set(index, value); + // @@protoc_insertion_point(field_set:bgs.protocol.Role.removable_role) +} +inline void Role::add_removable_role(::google::protobuf::uint32 value) { + removable_role_.Add(value); + // @@protoc_insertion_point(field_add:bgs.protocol.Role.removable_role) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +Role::removable_role() const { + // @@protoc_insertion_point(field_list:bgs.protocol.Role.removable_role) + return removable_role_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +Role::mutable_removable_role() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.Role.removable_role) + return &removable_role_; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_role_5ftypes_2eproto__INCLUDED diff --git a/src/server/proto/Client/rpc_config.pb.cc b/src/server/proto/Client/rpc_config.pb.cc new file mode 100644 index 00000000000..63597f6618d --- /dev/null +++ b/src/server/proto/Client/rpc_config.pb.cc @@ -0,0 +1,1952 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: rpc_config.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "rpc_config.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { +namespace config { + +namespace { + +const ::google::protobuf::Descriptor* RPCMethodConfig_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + RPCMethodConfig_reflection_ = NULL; +const ::google::protobuf::Descriptor* RPCMeterConfig_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + RPCMeterConfig_reflection_ = NULL; +const ::google::protobuf::Descriptor* ProtocolAlias_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ProtocolAlias_reflection_ = NULL; +const ::google::protobuf::Descriptor* ServiceAliases_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ServiceAliases_reflection_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_rpc_5fconfig_2eproto() { + protobuf_AddDesc_rpc_5fconfig_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "rpc_config.proto"); + GOOGLE_CHECK(file != NULL); + RPCMethodConfig_descriptor_ = file->message_type(0); + static const int RPCMethodConfig_offsets_[15] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, service_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, method_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, fixed_call_cost_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, fixed_packet_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, variable_multiplier_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, multiplier_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, rate_limit_count_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, rate_limit_seconds_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, max_packet_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, max_encoded_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, timeout_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, cap_balance_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, income_per_second_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, service_hash_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, method_id_), + }; + RPCMethodConfig_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + RPCMethodConfig_descriptor_, + RPCMethodConfig::default_instance_, + RPCMethodConfig_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(RPCMethodConfig)); + RPCMeterConfig_descriptor_ = file->message_type(1); + static const int RPCMeterConfig_offsets_[5] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMeterConfig, method_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMeterConfig, income_per_second_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMeterConfig, initial_balance_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMeterConfig, cap_balance_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMeterConfig, startup_period_), + }; + RPCMeterConfig_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + RPCMeterConfig_descriptor_, + RPCMeterConfig::default_instance_, + RPCMeterConfig_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMeterConfig, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMeterConfig, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(RPCMeterConfig)); + ProtocolAlias_descriptor_ = file->message_type(2); + static const int ProtocolAlias_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProtocolAlias, server_service_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProtocolAlias, client_service_name_), + }; + ProtocolAlias_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ProtocolAlias_descriptor_, + ProtocolAlias::default_instance_, + ProtocolAlias_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProtocolAlias, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProtocolAlias, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ProtocolAlias)); + ServiceAliases_descriptor_ = file->message_type(3); + static const int ServiceAliases_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceAliases, protocol_alias_), + }; + ServiceAliases_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ServiceAliases_descriptor_, + ServiceAliases::default_instance_, + ServiceAliases_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceAliases, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceAliases, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ServiceAliases)); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_rpc_5fconfig_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + RPCMethodConfig_descriptor_, &RPCMethodConfig::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + RPCMeterConfig_descriptor_, &RPCMeterConfig::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ProtocolAlias_descriptor_, &ProtocolAlias::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ServiceAliases_descriptor_, &ServiceAliases::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_rpc_5fconfig_2eproto() { + delete RPCMethodConfig::default_instance_; + delete RPCMethodConfig_reflection_; + delete RPCMeterConfig::default_instance_; + delete RPCMeterConfig_reflection_; + delete ProtocolAlias::default_instance_; + delete ProtocolAlias_reflection_; + delete ServiceAliases::default_instance_; + delete ServiceAliases_reflection_; +} + +void protobuf_AddDesc_rpc_5fconfig_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\020rpc_config.proto\022\023bgs.protocol.config\"" + "\213\003\n\017RPCMethodConfig\022\030\n\014service_name\030\001 \001(" + "\tB\002\030\001\022\027\n\013method_name\030\002 \001(\tB\002\030\001\022\032\n\017fixed_" + "call_cost\030\003 \001(\r:\0011\022\034\n\021fixed_packet_size\030" + "\004 \001(\r:\0010\022\036\n\023variable_multiplier\030\005 \001(\002:\0010" + "\022\025\n\nmultiplier\030\006 \001(\002:\0011\022\030\n\020rate_limit_co" + "unt\030\007 \001(\r\022\032\n\022rate_limit_seconds\030\010 \001(\r\022\027\n" + "\017max_packet_size\030\t \001(\r\022\030\n\020max_encoded_si" + "ze\030\n \001(\r\022\017\n\007timeout\030\013 \001(\002\022\023\n\013cap_balance" + "\030\014 \001(\r\022\034\n\021income_per_second\030\r \001(\002:\0010\022\024\n\014" + "service_hash\030\016 \001(\r\022\021\n\tmethod_id\030\017 \001(\r\"\255\001" + "\n\016RPCMeterConfig\0224\n\006method\030\001 \003(\0132$.bgs.p" + "rotocol.config.RPCMethodConfig\022\034\n\021income" + "_per_second\030\002 \001(\r:\0011\022\027\n\017initial_balance\030" + "\003 \001(\r\022\023\n\013cap_balance\030\004 \001(\r\022\031\n\016startup_pe" + "riod\030\005 \001(\002:\0010\"I\n\rProtocolAlias\022\033\n\023server" + "_service_name\030\001 \002(\t\022\033\n\023client_service_na" + "me\030\002 \002(\t\"L\n\016ServiceAliases\022:\n\016protocol_a" + "lias\030\001 \003(\0132\".bgs.protocol.config.Protoco" + "lAliasB\002H\001", 770); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "rpc_config.proto", &protobuf_RegisterTypes); + RPCMethodConfig::default_instance_ = new RPCMethodConfig(); + RPCMeterConfig::default_instance_ = new RPCMeterConfig(); + ProtocolAlias::default_instance_ = new ProtocolAlias(); + ServiceAliases::default_instance_ = new ServiceAliases(); + RPCMethodConfig::default_instance_->InitAsDefaultInstance(); + RPCMeterConfig::default_instance_->InitAsDefaultInstance(); + ProtocolAlias::default_instance_->InitAsDefaultInstance(); + ServiceAliases::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_rpc_5fconfig_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_rpc_5fconfig_2eproto { + StaticDescriptorInitializer_rpc_5fconfig_2eproto() { + protobuf_AddDesc_rpc_5fconfig_2eproto(); + } +} static_descriptor_initializer_rpc_5fconfig_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int RPCMethodConfig::kServiceNameFieldNumber; +const int RPCMethodConfig::kMethodNameFieldNumber; +const int RPCMethodConfig::kFixedCallCostFieldNumber; +const int RPCMethodConfig::kFixedPacketSizeFieldNumber; +const int RPCMethodConfig::kVariableMultiplierFieldNumber; +const int RPCMethodConfig::kMultiplierFieldNumber; +const int RPCMethodConfig::kRateLimitCountFieldNumber; +const int RPCMethodConfig::kRateLimitSecondsFieldNumber; +const int RPCMethodConfig::kMaxPacketSizeFieldNumber; +const int RPCMethodConfig::kMaxEncodedSizeFieldNumber; +const int RPCMethodConfig::kTimeoutFieldNumber; +const int RPCMethodConfig::kCapBalanceFieldNumber; +const int RPCMethodConfig::kIncomePerSecondFieldNumber; +const int RPCMethodConfig::kServiceHashFieldNumber; +const int RPCMethodConfig::kMethodIdFieldNumber; +#endif // !_MSC_VER + +RPCMethodConfig::RPCMethodConfig() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.config.RPCMethodConfig) +} + +void RPCMethodConfig::InitAsDefaultInstance() { +} + +RPCMethodConfig::RPCMethodConfig(const RPCMethodConfig& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.config.RPCMethodConfig) +} + +void RPCMethodConfig::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + service_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + method_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + fixed_call_cost_ = 1u; + fixed_packet_size_ = 0u; + variable_multiplier_ = 0; + multiplier_ = 1; + rate_limit_count_ = 0u; + rate_limit_seconds_ = 0u; + max_packet_size_ = 0u; + max_encoded_size_ = 0u; + timeout_ = 0; + cap_balance_ = 0u; + income_per_second_ = 0; + service_hash_ = 0u; + method_id_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +RPCMethodConfig::~RPCMethodConfig() { + // @@protoc_insertion_point(destructor:bgs.protocol.config.RPCMethodConfig) + SharedDtor(); +} + +void RPCMethodConfig::SharedDtor() { + if (service_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete service_name_; + } + if (method_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete method_name_; + } + if (this != default_instance_) { + } +} + +void RPCMethodConfig::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* RPCMethodConfig::descriptor() { + protobuf_AssignDescriptorsOnce(); + return RPCMethodConfig_descriptor_; +} + +const RPCMethodConfig& RPCMethodConfig::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_rpc_5fconfig_2eproto(); + return *default_instance_; +} + +RPCMethodConfig* RPCMethodConfig::default_instance_ = NULL; + +RPCMethodConfig* RPCMethodConfig::New() const { + return new RPCMethodConfig; +} + +void RPCMethodConfig::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(fixed_packet_size_, variable_multiplier_); + ZR_(rate_limit_count_, rate_limit_seconds_); + if (has_service_name()) { + if (service_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + service_name_->clear(); + } + } + if (has_method_name()) { + if (method_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + method_name_->clear(); + } + } + fixed_call_cost_ = 1u; + multiplier_ = 1; + } + if (_has_bits_[8 / 32] & 32512) { + ZR_(max_packet_size_, method_id_); + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool RPCMethodConfig::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.config.RPCMethodConfig) + 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 service_name = 1 [deprecated = true]; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_service_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->service_name().data(), this->service_name().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "service_name"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_method_name; + break; + } + + // optional string method_name = 2 [deprecated = true]; + case 2: { + if (tag == 18) { + parse_method_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_method_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->method_name().data(), this->method_name().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "method_name"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_fixed_call_cost; + break; + } + + // optional uint32 fixed_call_cost = 3 [default = 1]; + case 3: { + if (tag == 24) { + parse_fixed_call_cost: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &fixed_call_cost_))); + set_has_fixed_call_cost(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_fixed_packet_size; + break; + } + + // optional uint32 fixed_packet_size = 4 [default = 0]; + case 4: { + if (tag == 32) { + parse_fixed_packet_size: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &fixed_packet_size_))); + set_has_fixed_packet_size(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(45)) goto parse_variable_multiplier; + break; + } + + // optional float variable_multiplier = 5 [default = 0]; + case 5: { + if (tag == 45) { + parse_variable_multiplier: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &variable_multiplier_))); + set_has_variable_multiplier(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(53)) goto parse_multiplier; + break; + } + + // optional float multiplier = 6 [default = 1]; + case 6: { + if (tag == 53) { + parse_multiplier: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &multiplier_))); + set_has_multiplier(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(56)) goto parse_rate_limit_count; + break; + } + + // optional uint32 rate_limit_count = 7; + case 7: { + if (tag == 56) { + parse_rate_limit_count: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &rate_limit_count_))); + set_has_rate_limit_count(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(64)) goto parse_rate_limit_seconds; + break; + } + + // optional uint32 rate_limit_seconds = 8; + case 8: { + if (tag == 64) { + parse_rate_limit_seconds: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &rate_limit_seconds_))); + set_has_rate_limit_seconds(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(72)) goto parse_max_packet_size; + break; + } + + // optional uint32 max_packet_size = 9; + case 9: { + if (tag == 72) { + parse_max_packet_size: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &max_packet_size_))); + set_has_max_packet_size(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(80)) goto parse_max_encoded_size; + break; + } + + // optional uint32 max_encoded_size = 10; + case 10: { + if (tag == 80) { + parse_max_encoded_size: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &max_encoded_size_))); + set_has_max_encoded_size(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(93)) goto parse_timeout; + break; + } + + // optional float timeout = 11; + case 11: { + if (tag == 93) { + parse_timeout: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &timeout_))); + set_has_timeout(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(96)) goto parse_cap_balance; + break; + } + + // optional uint32 cap_balance = 12; + case 12: { + if (tag == 96) { + parse_cap_balance: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &cap_balance_))); + set_has_cap_balance(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(109)) goto parse_income_per_second; + break; + } + + // optional float income_per_second = 13 [default = 0]; + case 13: { + if (tag == 109) { + parse_income_per_second: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &income_per_second_))); + set_has_income_per_second(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(112)) goto parse_service_hash; + break; + } + + // optional uint32 service_hash = 14; + case 14: { + if (tag == 112) { + parse_service_hash: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &service_hash_))); + set_has_service_hash(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(120)) goto parse_method_id; + break; + } + + // optional uint32 method_id = 15; + case 15: { + if (tag == 120) { + parse_method_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &method_id_))); + set_has_method_id(); + } 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:bgs.protocol.config.RPCMethodConfig) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.config.RPCMethodConfig) + return false; +#undef DO_ +} + +void RPCMethodConfig::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.config.RPCMethodConfig) + // optional string service_name = 1 [deprecated = true]; + if (has_service_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->service_name().data(), this->service_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "service_name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->service_name(), output); + } + + // optional string method_name = 2 [deprecated = true]; + if (has_method_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->method_name().data(), this->method_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "method_name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->method_name(), output); + } + + // optional uint32 fixed_call_cost = 3 [default = 1]; + if (has_fixed_call_cost()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->fixed_call_cost(), output); + } + + // optional uint32 fixed_packet_size = 4 [default = 0]; + if (has_fixed_packet_size()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->fixed_packet_size(), output); + } + + // optional float variable_multiplier = 5 [default = 0]; + if (has_variable_multiplier()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(5, this->variable_multiplier(), output); + } + + // optional float multiplier = 6 [default = 1]; + if (has_multiplier()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(6, this->multiplier(), output); + } + + // optional uint32 rate_limit_count = 7; + if (has_rate_limit_count()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->rate_limit_count(), output); + } + + // optional uint32 rate_limit_seconds = 8; + if (has_rate_limit_seconds()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(8, this->rate_limit_seconds(), output); + } + + // optional uint32 max_packet_size = 9; + if (has_max_packet_size()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(9, this->max_packet_size(), output); + } + + // optional uint32 max_encoded_size = 10; + if (has_max_encoded_size()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(10, this->max_encoded_size(), output); + } + + // optional float timeout = 11; + if (has_timeout()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(11, this->timeout(), output); + } + + // optional uint32 cap_balance = 12; + if (has_cap_balance()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(12, this->cap_balance(), output); + } + + // optional float income_per_second = 13 [default = 0]; + if (has_income_per_second()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(13, this->income_per_second(), output); + } + + // optional uint32 service_hash = 14; + if (has_service_hash()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(14, this->service_hash(), output); + } + + // optional uint32 method_id = 15; + if (has_method_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(15, this->method_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.config.RPCMethodConfig) +} + +::google::protobuf::uint8* RPCMethodConfig::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.config.RPCMethodConfig) + // optional string service_name = 1 [deprecated = true]; + if (has_service_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->service_name().data(), this->service_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "service_name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->service_name(), target); + } + + // optional string method_name = 2 [deprecated = true]; + if (has_method_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->method_name().data(), this->method_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "method_name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->method_name(), target); + } + + // optional uint32 fixed_call_cost = 3 [default = 1]; + if (has_fixed_call_cost()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->fixed_call_cost(), target); + } + + // optional uint32 fixed_packet_size = 4 [default = 0]; + if (has_fixed_packet_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->fixed_packet_size(), target); + } + + // optional float variable_multiplier = 5 [default = 0]; + if (has_variable_multiplier()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(5, this->variable_multiplier(), target); + } + + // optional float multiplier = 6 [default = 1]; + if (has_multiplier()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(6, this->multiplier(), target); + } + + // optional uint32 rate_limit_count = 7; + if (has_rate_limit_count()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->rate_limit_count(), target); + } + + // optional uint32 rate_limit_seconds = 8; + if (has_rate_limit_seconds()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(8, this->rate_limit_seconds(), target); + } + + // optional uint32 max_packet_size = 9; + if (has_max_packet_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(9, this->max_packet_size(), target); + } + + // optional uint32 max_encoded_size = 10; + if (has_max_encoded_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(10, this->max_encoded_size(), target); + } + + // optional float timeout = 11; + if (has_timeout()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(11, this->timeout(), target); + } + + // optional uint32 cap_balance = 12; + if (has_cap_balance()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(12, this->cap_balance(), target); + } + + // optional float income_per_second = 13 [default = 0]; + if (has_income_per_second()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(13, this->income_per_second(), target); + } + + // optional uint32 service_hash = 14; + if (has_service_hash()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(14, this->service_hash(), target); + } + + // optional uint32 method_id = 15; + if (has_method_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(15, this->method_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.config.RPCMethodConfig) + return target; +} + +int RPCMethodConfig::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional string service_name = 1 [deprecated = true]; + if (has_service_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->service_name()); + } + + // optional string method_name = 2 [deprecated = true]; + if (has_method_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->method_name()); + } + + // optional uint32 fixed_call_cost = 3 [default = 1]; + if (has_fixed_call_cost()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->fixed_call_cost()); + } + + // optional uint32 fixed_packet_size = 4 [default = 0]; + if (has_fixed_packet_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->fixed_packet_size()); + } + + // optional float variable_multiplier = 5 [default = 0]; + if (has_variable_multiplier()) { + total_size += 1 + 4; + } + + // optional float multiplier = 6 [default = 1]; + if (has_multiplier()) { + total_size += 1 + 4; + } + + // optional uint32 rate_limit_count = 7; + if (has_rate_limit_count()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->rate_limit_count()); + } + + // optional uint32 rate_limit_seconds = 8; + if (has_rate_limit_seconds()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->rate_limit_seconds()); + } + + } + if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + // optional uint32 max_packet_size = 9; + if (has_max_packet_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->max_packet_size()); + } + + // optional uint32 max_encoded_size = 10; + if (has_max_encoded_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->max_encoded_size()); + } + + // optional float timeout = 11; + if (has_timeout()) { + total_size += 1 + 4; + } + + // optional uint32 cap_balance = 12; + if (has_cap_balance()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->cap_balance()); + } + + // optional float income_per_second = 13 [default = 0]; + if (has_income_per_second()) { + total_size += 1 + 4; + } + + // optional uint32 service_hash = 14; + if (has_service_hash()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->service_hash()); + } + + // optional uint32 method_id = 15; + if (has_method_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->method_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void RPCMethodConfig::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const RPCMethodConfig* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void RPCMethodConfig::MergeFrom(const RPCMethodConfig& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_service_name()) { + set_service_name(from.service_name()); + } + if (from.has_method_name()) { + set_method_name(from.method_name()); + } + if (from.has_fixed_call_cost()) { + set_fixed_call_cost(from.fixed_call_cost()); + } + if (from.has_fixed_packet_size()) { + set_fixed_packet_size(from.fixed_packet_size()); + } + if (from.has_variable_multiplier()) { + set_variable_multiplier(from.variable_multiplier()); + } + if (from.has_multiplier()) { + set_multiplier(from.multiplier()); + } + if (from.has_rate_limit_count()) { + set_rate_limit_count(from.rate_limit_count()); + } + if (from.has_rate_limit_seconds()) { + set_rate_limit_seconds(from.rate_limit_seconds()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from.has_max_packet_size()) { + set_max_packet_size(from.max_packet_size()); + } + if (from.has_max_encoded_size()) { + set_max_encoded_size(from.max_encoded_size()); + } + if (from.has_timeout()) { + set_timeout(from.timeout()); + } + if (from.has_cap_balance()) { + set_cap_balance(from.cap_balance()); + } + if (from.has_income_per_second()) { + set_income_per_second(from.income_per_second()); + } + if (from.has_service_hash()) { + set_service_hash(from.service_hash()); + } + if (from.has_method_id()) { + set_method_id(from.method_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void RPCMethodConfig::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RPCMethodConfig::CopyFrom(const RPCMethodConfig& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RPCMethodConfig::IsInitialized() const { + + return true; +} + +void RPCMethodConfig::Swap(RPCMethodConfig* other) { + if (other != this) { + std::swap(service_name_, other->service_name_); + std::swap(method_name_, other->method_name_); + std::swap(fixed_call_cost_, other->fixed_call_cost_); + std::swap(fixed_packet_size_, other->fixed_packet_size_); + std::swap(variable_multiplier_, other->variable_multiplier_); + std::swap(multiplier_, other->multiplier_); + std::swap(rate_limit_count_, other->rate_limit_count_); + std::swap(rate_limit_seconds_, other->rate_limit_seconds_); + std::swap(max_packet_size_, other->max_packet_size_); + std::swap(max_encoded_size_, other->max_encoded_size_); + std::swap(timeout_, other->timeout_); + std::swap(cap_balance_, other->cap_balance_); + std::swap(income_per_second_, other->income_per_second_); + std::swap(service_hash_, other->service_hash_); + std::swap(method_id_, other->method_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata RPCMethodConfig::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = RPCMethodConfig_descriptor_; + metadata.reflection = RPCMethodConfig_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int RPCMeterConfig::kMethodFieldNumber; +const int RPCMeterConfig::kIncomePerSecondFieldNumber; +const int RPCMeterConfig::kInitialBalanceFieldNumber; +const int RPCMeterConfig::kCapBalanceFieldNumber; +const int RPCMeterConfig::kStartupPeriodFieldNumber; +#endif // !_MSC_VER + +RPCMeterConfig::RPCMeterConfig() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.config.RPCMeterConfig) +} + +void RPCMeterConfig::InitAsDefaultInstance() { +} + +RPCMeterConfig::RPCMeterConfig(const RPCMeterConfig& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.config.RPCMeterConfig) +} + +void RPCMeterConfig::SharedCtor() { + _cached_size_ = 0; + income_per_second_ = 1u; + initial_balance_ = 0u; + cap_balance_ = 0u; + startup_period_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +RPCMeterConfig::~RPCMeterConfig() { + // @@protoc_insertion_point(destructor:bgs.protocol.config.RPCMeterConfig) + SharedDtor(); +} + +void RPCMeterConfig::SharedDtor() { + if (this != default_instance_) { + } +} + +void RPCMeterConfig::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* RPCMeterConfig::descriptor() { + protobuf_AssignDescriptorsOnce(); + return RPCMeterConfig_descriptor_; +} + +const RPCMeterConfig& RPCMeterConfig::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_rpc_5fconfig_2eproto(); + return *default_instance_; +} + +RPCMeterConfig* RPCMeterConfig::default_instance_ = NULL; + +RPCMeterConfig* RPCMeterConfig::New() const { + return new RPCMeterConfig; +} + +void RPCMeterConfig::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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] & 30) { + ZR_(initial_balance_, startup_period_); + income_per_second_ = 1u; + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + method_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool RPCMeterConfig::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.config.RPCMeterConfig) + 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 .bgs.protocol.config.RPCMethodConfig method = 1; + case 1: { + if (tag == 10) { + parse_method: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_method())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_method; + if (input->ExpectTag(16)) goto parse_income_per_second; + break; + } + + // optional uint32 income_per_second = 2 [default = 1]; + case 2: { + if (tag == 16) { + parse_income_per_second: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &income_per_second_))); + set_has_income_per_second(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_initial_balance; + break; + } + + // optional uint32 initial_balance = 3; + case 3: { + if (tag == 24) { + parse_initial_balance: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &initial_balance_))); + set_has_initial_balance(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_cap_balance; + break; + } + + // optional uint32 cap_balance = 4; + case 4: { + if (tag == 32) { + parse_cap_balance: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &cap_balance_))); + set_has_cap_balance(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(45)) goto parse_startup_period; + break; + } + + // optional float startup_period = 5 [default = 0]; + case 5: { + if (tag == 45) { + parse_startup_period: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &startup_period_))); + set_has_startup_period(); + } 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:bgs.protocol.config.RPCMeterConfig) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.config.RPCMeterConfig) + return false; +#undef DO_ +} + +void RPCMeterConfig::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.config.RPCMeterConfig) + // repeated .bgs.protocol.config.RPCMethodConfig method = 1; + for (int i = 0; i < this->method_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->method(i), output); + } + + // optional uint32 income_per_second = 2 [default = 1]; + if (has_income_per_second()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->income_per_second(), output); + } + + // optional uint32 initial_balance = 3; + if (has_initial_balance()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->initial_balance(), output); + } + + // optional uint32 cap_balance = 4; + if (has_cap_balance()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->cap_balance(), output); + } + + // optional float startup_period = 5 [default = 0]; + if (has_startup_period()) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(5, this->startup_period(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.config.RPCMeterConfig) +} + +::google::protobuf::uint8* RPCMeterConfig::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.config.RPCMeterConfig) + // repeated .bgs.protocol.config.RPCMethodConfig method = 1; + for (int i = 0; i < this->method_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->method(i), target); + } + + // optional uint32 income_per_second = 2 [default = 1]; + if (has_income_per_second()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->income_per_second(), target); + } + + // optional uint32 initial_balance = 3; + if (has_initial_balance()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->initial_balance(), target); + } + + // optional uint32 cap_balance = 4; + if (has_cap_balance()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->cap_balance(), target); + } + + // optional float startup_period = 5 [default = 0]; + if (has_startup_period()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(5, this->startup_period(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.config.RPCMeterConfig) + return target; +} + +int RPCMeterConfig::ByteSize() const { + int total_size = 0; + + if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) { + // optional uint32 income_per_second = 2 [default = 1]; + if (has_income_per_second()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->income_per_second()); + } + + // optional uint32 initial_balance = 3; + if (has_initial_balance()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->initial_balance()); + } + + // optional uint32 cap_balance = 4; + if (has_cap_balance()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->cap_balance()); + } + + // optional float startup_period = 5 [default = 0]; + if (has_startup_period()) { + total_size += 1 + 4; + } + + } + // repeated .bgs.protocol.config.RPCMethodConfig method = 1; + total_size += 1 * this->method_size(); + for (int i = 0; i < this->method_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->method(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 RPCMeterConfig::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const RPCMeterConfig* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void RPCMeterConfig::MergeFrom(const RPCMeterConfig& from) { + GOOGLE_CHECK_NE(&from, this); + method_.MergeFrom(from.method_); + if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) { + if (from.has_income_per_second()) { + set_income_per_second(from.income_per_second()); + } + if (from.has_initial_balance()) { + set_initial_balance(from.initial_balance()); + } + if (from.has_cap_balance()) { + set_cap_balance(from.cap_balance()); + } + if (from.has_startup_period()) { + set_startup_period(from.startup_period()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void RPCMeterConfig::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RPCMeterConfig::CopyFrom(const RPCMeterConfig& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RPCMeterConfig::IsInitialized() const { + + return true; +} + +void RPCMeterConfig::Swap(RPCMeterConfig* other) { + if (other != this) { + method_.Swap(&other->method_); + std::swap(income_per_second_, other->income_per_second_); + std::swap(initial_balance_, other->initial_balance_); + std::swap(cap_balance_, other->cap_balance_); + std::swap(startup_period_, other->startup_period_); + 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 RPCMeterConfig::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = RPCMeterConfig_descriptor_; + metadata.reflection = RPCMeterConfig_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ProtocolAlias::kServerServiceNameFieldNumber; +const int ProtocolAlias::kClientServiceNameFieldNumber; +#endif // !_MSC_VER + +ProtocolAlias::ProtocolAlias() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.config.ProtocolAlias) +} + +void ProtocolAlias::InitAsDefaultInstance() { +} + +ProtocolAlias::ProtocolAlias(const ProtocolAlias& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.config.ProtocolAlias) +} + +void ProtocolAlias::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + server_service_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + client_service_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ProtocolAlias::~ProtocolAlias() { + // @@protoc_insertion_point(destructor:bgs.protocol.config.ProtocolAlias) + SharedDtor(); +} + +void ProtocolAlias::SharedDtor() { + if (server_service_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete server_service_name_; + } + if (client_service_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete client_service_name_; + } + if (this != default_instance_) { + } +} + +void ProtocolAlias::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ProtocolAlias::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ProtocolAlias_descriptor_; +} + +const ProtocolAlias& ProtocolAlias::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_rpc_5fconfig_2eproto(); + return *default_instance_; +} + +ProtocolAlias* ProtocolAlias::default_instance_ = NULL; + +ProtocolAlias* ProtocolAlias::New() const { + return new ProtocolAlias; +} + +void ProtocolAlias::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_server_service_name()) { + if (server_service_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + server_service_name_->clear(); + } + } + if (has_client_service_name()) { + if (client_service_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_service_name_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ProtocolAlias::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.config.ProtocolAlias) + 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)) { + // required string server_service_name = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_server_service_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->server_service_name().data(), this->server_service_name().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "server_service_name"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_client_service_name; + break; + } + + // required string client_service_name = 2; + case 2: { + if (tag == 18) { + parse_client_service_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_client_service_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->client_service_name().data(), this->client_service_name().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "client_service_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:bgs.protocol.config.ProtocolAlias) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.config.ProtocolAlias) + return false; +#undef DO_ +} + +void ProtocolAlias::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.config.ProtocolAlias) + // required string server_service_name = 1; + if (has_server_service_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->server_service_name().data(), this->server_service_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "server_service_name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->server_service_name(), output); + } + + // required string client_service_name = 2; + if (has_client_service_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->client_service_name().data(), this->client_service_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "client_service_name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->client_service_name(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.config.ProtocolAlias) +} + +::google::protobuf::uint8* ProtocolAlias::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.config.ProtocolAlias) + // required string server_service_name = 1; + if (has_server_service_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->server_service_name().data(), this->server_service_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "server_service_name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->server_service_name(), target); + } + + // required string client_service_name = 2; + if (has_client_service_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->client_service_name().data(), this->client_service_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "client_service_name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->client_service_name(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.config.ProtocolAlias) + return target; +} + +int ProtocolAlias::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string server_service_name = 1; + if (has_server_service_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->server_service_name()); + } + + // required string client_service_name = 2; + if (has_client_service_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->client_service_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 ProtocolAlias::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ProtocolAlias* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ProtocolAlias::MergeFrom(const ProtocolAlias& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_server_service_name()) { + set_server_service_name(from.server_service_name()); + } + if (from.has_client_service_name()) { + set_client_service_name(from.client_service_name()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ProtocolAlias::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ProtocolAlias::CopyFrom(const ProtocolAlias& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ProtocolAlias::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void ProtocolAlias::Swap(ProtocolAlias* other) { + if (other != this) { + std::swap(server_service_name_, other->server_service_name_); + std::swap(client_service_name_, other->client_service_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 ProtocolAlias::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ProtocolAlias_descriptor_; + metadata.reflection = ProtocolAlias_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ServiceAliases::kProtocolAliasFieldNumber; +#endif // !_MSC_VER + +ServiceAliases::ServiceAliases() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.config.ServiceAliases) +} + +void ServiceAliases::InitAsDefaultInstance() { +} + +ServiceAliases::ServiceAliases(const ServiceAliases& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.config.ServiceAliases) +} + +void ServiceAliases::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ServiceAliases::~ServiceAliases() { + // @@protoc_insertion_point(destructor:bgs.protocol.config.ServiceAliases) + SharedDtor(); +} + +void ServiceAliases::SharedDtor() { + if (this != default_instance_) { + } +} + +void ServiceAliases::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ServiceAliases::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ServiceAliases_descriptor_; +} + +const ServiceAliases& ServiceAliases::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_rpc_5fconfig_2eproto(); + return *default_instance_; +} + +ServiceAliases* ServiceAliases::default_instance_ = NULL; + +ServiceAliases* ServiceAliases::New() const { + return new ServiceAliases; +} + +void ServiceAliases::Clear() { + protocol_alias_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ServiceAliases::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.config.ServiceAliases) + 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 .bgs.protocol.config.ProtocolAlias protocol_alias = 1; + case 1: { + if (tag == 10) { + parse_protocol_alias: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_protocol_alias())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_protocol_alias; + 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:bgs.protocol.config.ServiceAliases) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.config.ServiceAliases) + return false; +#undef DO_ +} + +void ServiceAliases::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.config.ServiceAliases) + // repeated .bgs.protocol.config.ProtocolAlias protocol_alias = 1; + for (int i = 0; i < this->protocol_alias_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->protocol_alias(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.config.ServiceAliases) +} + +::google::protobuf::uint8* ServiceAliases::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.config.ServiceAliases) + // repeated .bgs.protocol.config.ProtocolAlias protocol_alias = 1; + for (int i = 0; i < this->protocol_alias_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->protocol_alias(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.config.ServiceAliases) + return target; +} + +int ServiceAliases::ByteSize() const { + int total_size = 0; + + // repeated .bgs.protocol.config.ProtocolAlias protocol_alias = 1; + total_size += 1 * this->protocol_alias_size(); + for (int i = 0; i < this->protocol_alias_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->protocol_alias(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 ServiceAliases::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ServiceAliases* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ServiceAliases::MergeFrom(const ServiceAliases& from) { + GOOGLE_CHECK_NE(&from, this); + protocol_alias_.MergeFrom(from.protocol_alias_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ServiceAliases::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ServiceAliases::CopyFrom(const ServiceAliases& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ServiceAliases::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->protocol_alias())) return false; + return true; +} + +void ServiceAliases::Swap(ServiceAliases* other) { + if (other != this) { + protocol_alias_.Swap(&other->protocol_alias_); + 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 ServiceAliases::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ServiceAliases_descriptor_; + metadata.reflection = ServiceAliases_reflection_; + return metadata; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace config +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/rpc_config.pb.h b/src/server/proto/Client/rpc_config.pb.h new file mode 100644 index 00000000000..08bc1675f57 --- /dev/null +++ b/src/server/proto/Client/rpc_config.pb.h @@ -0,0 +1,1388 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: rpc_config.proto + +#ifndef PROTOBUF_rpc_5fconfig_2eproto__INCLUDED +#define PROTOBUF_rpc_5fconfig_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include "Define.h" // for TRINITY_SHARED_API +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { +namespace config { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_rpc_5fconfig_2eproto(); +void protobuf_AssignDesc_rpc_5fconfig_2eproto(); +void protobuf_ShutdownFile_rpc_5fconfig_2eproto(); + +class RPCMethodConfig; +class RPCMeterConfig; +class ProtocolAlias; +class ServiceAliases; + +// =================================================================== + +class TC_SHARED_API RPCMethodConfig : public ::google::protobuf::Message { + public: + RPCMethodConfig(); + virtual ~RPCMethodConfig(); + + RPCMethodConfig(const RPCMethodConfig& from); + + inline RPCMethodConfig& operator=(const RPCMethodConfig& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const RPCMethodConfig& default_instance(); + + void Swap(RPCMethodConfig* other); + + // implements Message ---------------------------------------------- + + RPCMethodConfig* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const RPCMethodConfig& from); + void MergeFrom(const RPCMethodConfig& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string service_name = 1 [deprecated = true]; + inline bool has_service_name() const PROTOBUF_DEPRECATED; + inline void clear_service_name() PROTOBUF_DEPRECATED; + static const int kServiceNameFieldNumber = 1; + inline const ::std::string& service_name() const PROTOBUF_DEPRECATED; + inline void set_service_name(const ::std::string& value) PROTOBUF_DEPRECATED; + inline void set_service_name(const char* value) PROTOBUF_DEPRECATED; + inline void set_service_name(const char* value, size_t size) PROTOBUF_DEPRECATED; + inline ::std::string* mutable_service_name() PROTOBUF_DEPRECATED; + inline ::std::string* release_service_name() PROTOBUF_DEPRECATED; + inline void set_allocated_service_name(::std::string* service_name) PROTOBUF_DEPRECATED; + + // optional string method_name = 2 [deprecated = true]; + inline bool has_method_name() const PROTOBUF_DEPRECATED; + inline void clear_method_name() PROTOBUF_DEPRECATED; + static const int kMethodNameFieldNumber = 2; + inline const ::std::string& method_name() const PROTOBUF_DEPRECATED; + inline void set_method_name(const ::std::string& value) PROTOBUF_DEPRECATED; + inline void set_method_name(const char* value) PROTOBUF_DEPRECATED; + inline void set_method_name(const char* value, size_t size) PROTOBUF_DEPRECATED; + inline ::std::string* mutable_method_name() PROTOBUF_DEPRECATED; + inline ::std::string* release_method_name() PROTOBUF_DEPRECATED; + inline void set_allocated_method_name(::std::string* method_name) PROTOBUF_DEPRECATED; + + // optional uint32 fixed_call_cost = 3 [default = 1]; + inline bool has_fixed_call_cost() const; + inline void clear_fixed_call_cost(); + static const int kFixedCallCostFieldNumber = 3; + inline ::google::protobuf::uint32 fixed_call_cost() const; + inline void set_fixed_call_cost(::google::protobuf::uint32 value); + + // optional uint32 fixed_packet_size = 4 [default = 0]; + inline bool has_fixed_packet_size() const; + inline void clear_fixed_packet_size(); + static const int kFixedPacketSizeFieldNumber = 4; + inline ::google::protobuf::uint32 fixed_packet_size() const; + inline void set_fixed_packet_size(::google::protobuf::uint32 value); + + // optional float variable_multiplier = 5 [default = 0]; + inline bool has_variable_multiplier() const; + inline void clear_variable_multiplier(); + static const int kVariableMultiplierFieldNumber = 5; + inline float variable_multiplier() const; + inline void set_variable_multiplier(float value); + + // optional float multiplier = 6 [default = 1]; + inline bool has_multiplier() const; + inline void clear_multiplier(); + static const int kMultiplierFieldNumber = 6; + inline float multiplier() const; + inline void set_multiplier(float value); + + // optional uint32 rate_limit_count = 7; + inline bool has_rate_limit_count() const; + inline void clear_rate_limit_count(); + static const int kRateLimitCountFieldNumber = 7; + inline ::google::protobuf::uint32 rate_limit_count() const; + inline void set_rate_limit_count(::google::protobuf::uint32 value); + + // optional uint32 rate_limit_seconds = 8; + inline bool has_rate_limit_seconds() const; + inline void clear_rate_limit_seconds(); + static const int kRateLimitSecondsFieldNumber = 8; + inline ::google::protobuf::uint32 rate_limit_seconds() const; + inline void set_rate_limit_seconds(::google::protobuf::uint32 value); + + // optional uint32 max_packet_size = 9; + inline bool has_max_packet_size() const; + inline void clear_max_packet_size(); + static const int kMaxPacketSizeFieldNumber = 9; + inline ::google::protobuf::uint32 max_packet_size() const; + inline void set_max_packet_size(::google::protobuf::uint32 value); + + // optional uint32 max_encoded_size = 10; + inline bool has_max_encoded_size() const; + inline void clear_max_encoded_size(); + static const int kMaxEncodedSizeFieldNumber = 10; + inline ::google::protobuf::uint32 max_encoded_size() const; + inline void set_max_encoded_size(::google::protobuf::uint32 value); + + // optional float timeout = 11; + inline bool has_timeout() const; + inline void clear_timeout(); + static const int kTimeoutFieldNumber = 11; + inline float timeout() const; + inline void set_timeout(float value); + + // optional uint32 cap_balance = 12; + inline bool has_cap_balance() const; + inline void clear_cap_balance(); + static const int kCapBalanceFieldNumber = 12; + inline ::google::protobuf::uint32 cap_balance() const; + inline void set_cap_balance(::google::protobuf::uint32 value); + + // optional float income_per_second = 13 [default = 0]; + inline bool has_income_per_second() const; + inline void clear_income_per_second(); + static const int kIncomePerSecondFieldNumber = 13; + inline float income_per_second() const; + inline void set_income_per_second(float value); + + // optional uint32 service_hash = 14; + inline bool has_service_hash() const; + inline void clear_service_hash(); + static const int kServiceHashFieldNumber = 14; + inline ::google::protobuf::uint32 service_hash() const; + inline void set_service_hash(::google::protobuf::uint32 value); + + // optional uint32 method_id = 15; + inline bool has_method_id() const; + inline void clear_method_id(); + static const int kMethodIdFieldNumber = 15; + inline ::google::protobuf::uint32 method_id() const; + inline void set_method_id(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.config.RPCMethodConfig) + private: + inline void set_has_service_name(); + inline void clear_has_service_name(); + inline void set_has_method_name(); + inline void clear_has_method_name(); + inline void set_has_fixed_call_cost(); + inline void clear_has_fixed_call_cost(); + inline void set_has_fixed_packet_size(); + inline void clear_has_fixed_packet_size(); + inline void set_has_variable_multiplier(); + inline void clear_has_variable_multiplier(); + inline void set_has_multiplier(); + inline void clear_has_multiplier(); + inline void set_has_rate_limit_count(); + inline void clear_has_rate_limit_count(); + inline void set_has_rate_limit_seconds(); + inline void clear_has_rate_limit_seconds(); + inline void set_has_max_packet_size(); + inline void clear_has_max_packet_size(); + inline void set_has_max_encoded_size(); + inline void clear_has_max_encoded_size(); + inline void set_has_timeout(); + inline void clear_has_timeout(); + inline void set_has_cap_balance(); + inline void clear_has_cap_balance(); + inline void set_has_income_per_second(); + inline void clear_has_income_per_second(); + inline void set_has_service_hash(); + inline void clear_has_service_hash(); + inline void set_has_method_id(); + inline void clear_has_method_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* service_name_; + ::std::string* method_name_; + ::google::protobuf::uint32 fixed_call_cost_; + ::google::protobuf::uint32 fixed_packet_size_; + float variable_multiplier_; + float multiplier_; + ::google::protobuf::uint32 rate_limit_count_; + ::google::protobuf::uint32 rate_limit_seconds_; + ::google::protobuf::uint32 max_packet_size_; + ::google::protobuf::uint32 max_encoded_size_; + float timeout_; + ::google::protobuf::uint32 cap_balance_; + float income_per_second_; + ::google::protobuf::uint32 service_hash_; + ::google::protobuf::uint32 method_id_; + friend void TC_SHARED_API protobuf_AddDesc_rpc_5fconfig_2eproto(); + friend void protobuf_AssignDesc_rpc_5fconfig_2eproto(); + friend void protobuf_ShutdownFile_rpc_5fconfig_2eproto(); + + void InitAsDefaultInstance(); + static RPCMethodConfig* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API RPCMeterConfig : public ::google::protobuf::Message { + public: + RPCMeterConfig(); + virtual ~RPCMeterConfig(); + + RPCMeterConfig(const RPCMeterConfig& from); + + inline RPCMeterConfig& operator=(const RPCMeterConfig& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const RPCMeterConfig& default_instance(); + + void Swap(RPCMeterConfig* other); + + // implements Message ---------------------------------------------- + + RPCMeterConfig* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const RPCMeterConfig& from); + void MergeFrom(const RPCMeterConfig& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.config.RPCMethodConfig method = 1; + inline int method_size() const; + inline void clear_method(); + static const int kMethodFieldNumber = 1; + inline const ::bgs::protocol::config::RPCMethodConfig& method(int index) const; + inline ::bgs::protocol::config::RPCMethodConfig* mutable_method(int index); + inline ::bgs::protocol::config::RPCMethodConfig* add_method(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::config::RPCMethodConfig >& + method() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::config::RPCMethodConfig >* + mutable_method(); + + // optional uint32 income_per_second = 2 [default = 1]; + inline bool has_income_per_second() const; + inline void clear_income_per_second(); + static const int kIncomePerSecondFieldNumber = 2; + inline ::google::protobuf::uint32 income_per_second() const; + inline void set_income_per_second(::google::protobuf::uint32 value); + + // optional uint32 initial_balance = 3; + inline bool has_initial_balance() const; + inline void clear_initial_balance(); + static const int kInitialBalanceFieldNumber = 3; + inline ::google::protobuf::uint32 initial_balance() const; + inline void set_initial_balance(::google::protobuf::uint32 value); + + // optional uint32 cap_balance = 4; + inline bool has_cap_balance() const; + inline void clear_cap_balance(); + static const int kCapBalanceFieldNumber = 4; + inline ::google::protobuf::uint32 cap_balance() const; + inline void set_cap_balance(::google::protobuf::uint32 value); + + // optional float startup_period = 5 [default = 0]; + inline bool has_startup_period() const; + inline void clear_startup_period(); + static const int kStartupPeriodFieldNumber = 5; + inline float startup_period() const; + inline void set_startup_period(float value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.config.RPCMeterConfig) + private: + inline void set_has_income_per_second(); + inline void clear_has_income_per_second(); + inline void set_has_initial_balance(); + inline void clear_has_initial_balance(); + inline void set_has_cap_balance(); + inline void clear_has_cap_balance(); + inline void set_has_startup_period(); + inline void clear_has_startup_period(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::config::RPCMethodConfig > method_; + ::google::protobuf::uint32 income_per_second_; + ::google::protobuf::uint32 initial_balance_; + ::google::protobuf::uint32 cap_balance_; + float startup_period_; + friend void TC_SHARED_API protobuf_AddDesc_rpc_5fconfig_2eproto(); + friend void protobuf_AssignDesc_rpc_5fconfig_2eproto(); + friend void protobuf_ShutdownFile_rpc_5fconfig_2eproto(); + + void InitAsDefaultInstance(); + static RPCMeterConfig* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ProtocolAlias : public ::google::protobuf::Message { + public: + ProtocolAlias(); + virtual ~ProtocolAlias(); + + ProtocolAlias(const ProtocolAlias& from); + + inline ProtocolAlias& operator=(const ProtocolAlias& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ProtocolAlias& default_instance(); + + void Swap(ProtocolAlias* other); + + // implements Message ---------------------------------------------- + + ProtocolAlias* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ProtocolAlias& from); + void MergeFrom(const ProtocolAlias& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string server_service_name = 1; + inline bool has_server_service_name() const; + inline void clear_server_service_name(); + static const int kServerServiceNameFieldNumber = 1; + inline const ::std::string& server_service_name() const; + inline void set_server_service_name(const ::std::string& value); + inline void set_server_service_name(const char* value); + inline void set_server_service_name(const char* value, size_t size); + inline ::std::string* mutable_server_service_name(); + inline ::std::string* release_server_service_name(); + inline void set_allocated_server_service_name(::std::string* server_service_name); + + // required string client_service_name = 2; + inline bool has_client_service_name() const; + inline void clear_client_service_name(); + static const int kClientServiceNameFieldNumber = 2; + inline const ::std::string& client_service_name() const; + inline void set_client_service_name(const ::std::string& value); + inline void set_client_service_name(const char* value); + inline void set_client_service_name(const char* value, size_t size); + inline ::std::string* mutable_client_service_name(); + inline ::std::string* release_client_service_name(); + inline void set_allocated_client_service_name(::std::string* client_service_name); + + // @@protoc_insertion_point(class_scope:bgs.protocol.config.ProtocolAlias) + private: + inline void set_has_server_service_name(); + inline void clear_has_server_service_name(); + inline void set_has_client_service_name(); + inline void clear_has_client_service_name(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* server_service_name_; + ::std::string* client_service_name_; + friend void TC_SHARED_API protobuf_AddDesc_rpc_5fconfig_2eproto(); + friend void protobuf_AssignDesc_rpc_5fconfig_2eproto(); + friend void protobuf_ShutdownFile_rpc_5fconfig_2eproto(); + + void InitAsDefaultInstance(); + static ProtocolAlias* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ServiceAliases : public ::google::protobuf::Message { + public: + ServiceAliases(); + virtual ~ServiceAliases(); + + ServiceAliases(const ServiceAliases& from); + + inline ServiceAliases& operator=(const ServiceAliases& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ServiceAliases& default_instance(); + + void Swap(ServiceAliases* other); + + // implements Message ---------------------------------------------- + + ServiceAliases* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ServiceAliases& from); + void MergeFrom(const ServiceAliases& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.config.ProtocolAlias protocol_alias = 1; + inline int protocol_alias_size() const; + inline void clear_protocol_alias(); + static const int kProtocolAliasFieldNumber = 1; + inline const ::bgs::protocol::config::ProtocolAlias& protocol_alias(int index) const; + inline ::bgs::protocol::config::ProtocolAlias* mutable_protocol_alias(int index); + inline ::bgs::protocol::config::ProtocolAlias* add_protocol_alias(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::config::ProtocolAlias >& + protocol_alias() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::config::ProtocolAlias >* + mutable_protocol_alias(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.config.ServiceAliases) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::config::ProtocolAlias > protocol_alias_; + friend void TC_SHARED_API protobuf_AddDesc_rpc_5fconfig_2eproto(); + friend void protobuf_AssignDesc_rpc_5fconfig_2eproto(); + friend void protobuf_ShutdownFile_rpc_5fconfig_2eproto(); + + void InitAsDefaultInstance(); + static ServiceAliases* default_instance_; +}; +// =================================================================== + + +// =================================================================== + + +// =================================================================== + +// RPCMethodConfig + +// optional string service_name = 1 [deprecated = true]; +inline bool RPCMethodConfig::has_service_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void RPCMethodConfig::set_has_service_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void RPCMethodConfig::clear_has_service_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void RPCMethodConfig::clear_service_name() { + if (service_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + service_name_->clear(); + } + clear_has_service_name(); +} +inline const ::std::string& RPCMethodConfig::service_name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.service_name) + return *service_name_; +} +inline void RPCMethodConfig::set_service_name(const ::std::string& value) { + set_has_service_name(); + if (service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + service_name_ = new ::std::string; + } + service_name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.service_name) +} +inline void RPCMethodConfig::set_service_name(const char* value) { + set_has_service_name(); + if (service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + service_name_ = new ::std::string; + } + service_name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.config.RPCMethodConfig.service_name) +} +inline void RPCMethodConfig::set_service_name(const char* value, size_t size) { + set_has_service_name(); + if (service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + service_name_ = new ::std::string; + } + service_name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.config.RPCMethodConfig.service_name) +} +inline ::std::string* RPCMethodConfig::mutable_service_name() { + set_has_service_name(); + if (service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + service_name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.config.RPCMethodConfig.service_name) + return service_name_; +} +inline ::std::string* RPCMethodConfig::release_service_name() { + clear_has_service_name(); + if (service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = service_name_; + service_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void RPCMethodConfig::set_allocated_service_name(::std::string* service_name) { + if (service_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete service_name_; + } + if (service_name) { + set_has_service_name(); + service_name_ = service_name; + } else { + clear_has_service_name(); + service_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.config.RPCMethodConfig.service_name) +} + +// optional string method_name = 2 [deprecated = true]; +inline bool RPCMethodConfig::has_method_name() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void RPCMethodConfig::set_has_method_name() { + _has_bits_[0] |= 0x00000002u; +} +inline void RPCMethodConfig::clear_has_method_name() { + _has_bits_[0] &= ~0x00000002u; +} +inline void RPCMethodConfig::clear_method_name() { + if (method_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + method_name_->clear(); + } + clear_has_method_name(); +} +inline const ::std::string& RPCMethodConfig::method_name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.method_name) + return *method_name_; +} +inline void RPCMethodConfig::set_method_name(const ::std::string& value) { + set_has_method_name(); + if (method_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + method_name_ = new ::std::string; + } + method_name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.method_name) +} +inline void RPCMethodConfig::set_method_name(const char* value) { + set_has_method_name(); + if (method_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + method_name_ = new ::std::string; + } + method_name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.config.RPCMethodConfig.method_name) +} +inline void RPCMethodConfig::set_method_name(const char* value, size_t size) { + set_has_method_name(); + if (method_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + method_name_ = new ::std::string; + } + method_name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.config.RPCMethodConfig.method_name) +} +inline ::std::string* RPCMethodConfig::mutable_method_name() { + set_has_method_name(); + if (method_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + method_name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.config.RPCMethodConfig.method_name) + return method_name_; +} +inline ::std::string* RPCMethodConfig::release_method_name() { + clear_has_method_name(); + if (method_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = method_name_; + method_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void RPCMethodConfig::set_allocated_method_name(::std::string* method_name) { + if (method_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete method_name_; + } + if (method_name) { + set_has_method_name(); + method_name_ = method_name; + } else { + clear_has_method_name(); + method_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.config.RPCMethodConfig.method_name) +} + +// optional uint32 fixed_call_cost = 3 [default = 1]; +inline bool RPCMethodConfig::has_fixed_call_cost() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void RPCMethodConfig::set_has_fixed_call_cost() { + _has_bits_[0] |= 0x00000004u; +} +inline void RPCMethodConfig::clear_has_fixed_call_cost() { + _has_bits_[0] &= ~0x00000004u; +} +inline void RPCMethodConfig::clear_fixed_call_cost() { + fixed_call_cost_ = 1u; + clear_has_fixed_call_cost(); +} +inline ::google::protobuf::uint32 RPCMethodConfig::fixed_call_cost() const { + // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.fixed_call_cost) + return fixed_call_cost_; +} +inline void RPCMethodConfig::set_fixed_call_cost(::google::protobuf::uint32 value) { + set_has_fixed_call_cost(); + fixed_call_cost_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.fixed_call_cost) +} + +// optional uint32 fixed_packet_size = 4 [default = 0]; +inline bool RPCMethodConfig::has_fixed_packet_size() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void RPCMethodConfig::set_has_fixed_packet_size() { + _has_bits_[0] |= 0x00000008u; +} +inline void RPCMethodConfig::clear_has_fixed_packet_size() { + _has_bits_[0] &= ~0x00000008u; +} +inline void RPCMethodConfig::clear_fixed_packet_size() { + fixed_packet_size_ = 0u; + clear_has_fixed_packet_size(); +} +inline ::google::protobuf::uint32 RPCMethodConfig::fixed_packet_size() const { + // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.fixed_packet_size) + return fixed_packet_size_; +} +inline void RPCMethodConfig::set_fixed_packet_size(::google::protobuf::uint32 value) { + set_has_fixed_packet_size(); + fixed_packet_size_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.fixed_packet_size) +} + +// optional float variable_multiplier = 5 [default = 0]; +inline bool RPCMethodConfig::has_variable_multiplier() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void RPCMethodConfig::set_has_variable_multiplier() { + _has_bits_[0] |= 0x00000010u; +} +inline void RPCMethodConfig::clear_has_variable_multiplier() { + _has_bits_[0] &= ~0x00000010u; +} +inline void RPCMethodConfig::clear_variable_multiplier() { + variable_multiplier_ = 0; + clear_has_variable_multiplier(); +} +inline float RPCMethodConfig::variable_multiplier() const { + // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.variable_multiplier) + return variable_multiplier_; +} +inline void RPCMethodConfig::set_variable_multiplier(float value) { + set_has_variable_multiplier(); + variable_multiplier_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.variable_multiplier) +} + +// optional float multiplier = 6 [default = 1]; +inline bool RPCMethodConfig::has_multiplier() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void RPCMethodConfig::set_has_multiplier() { + _has_bits_[0] |= 0x00000020u; +} +inline void RPCMethodConfig::clear_has_multiplier() { + _has_bits_[0] &= ~0x00000020u; +} +inline void RPCMethodConfig::clear_multiplier() { + multiplier_ = 1; + clear_has_multiplier(); +} +inline float RPCMethodConfig::multiplier() const { + // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.multiplier) + return multiplier_; +} +inline void RPCMethodConfig::set_multiplier(float value) { + set_has_multiplier(); + multiplier_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.multiplier) +} + +// optional uint32 rate_limit_count = 7; +inline bool RPCMethodConfig::has_rate_limit_count() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void RPCMethodConfig::set_has_rate_limit_count() { + _has_bits_[0] |= 0x00000040u; +} +inline void RPCMethodConfig::clear_has_rate_limit_count() { + _has_bits_[0] &= ~0x00000040u; +} +inline void RPCMethodConfig::clear_rate_limit_count() { + rate_limit_count_ = 0u; + clear_has_rate_limit_count(); +} +inline ::google::protobuf::uint32 RPCMethodConfig::rate_limit_count() const { + // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.rate_limit_count) + return rate_limit_count_; +} +inline void RPCMethodConfig::set_rate_limit_count(::google::protobuf::uint32 value) { + set_has_rate_limit_count(); + rate_limit_count_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.rate_limit_count) +} + +// optional uint32 rate_limit_seconds = 8; +inline bool RPCMethodConfig::has_rate_limit_seconds() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void RPCMethodConfig::set_has_rate_limit_seconds() { + _has_bits_[0] |= 0x00000080u; +} +inline void RPCMethodConfig::clear_has_rate_limit_seconds() { + _has_bits_[0] &= ~0x00000080u; +} +inline void RPCMethodConfig::clear_rate_limit_seconds() { + rate_limit_seconds_ = 0u; + clear_has_rate_limit_seconds(); +} +inline ::google::protobuf::uint32 RPCMethodConfig::rate_limit_seconds() const { + // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.rate_limit_seconds) + return rate_limit_seconds_; +} +inline void RPCMethodConfig::set_rate_limit_seconds(::google::protobuf::uint32 value) { + set_has_rate_limit_seconds(); + rate_limit_seconds_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.rate_limit_seconds) +} + +// optional uint32 max_packet_size = 9; +inline bool RPCMethodConfig::has_max_packet_size() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void RPCMethodConfig::set_has_max_packet_size() { + _has_bits_[0] |= 0x00000100u; +} +inline void RPCMethodConfig::clear_has_max_packet_size() { + _has_bits_[0] &= ~0x00000100u; +} +inline void RPCMethodConfig::clear_max_packet_size() { + max_packet_size_ = 0u; + clear_has_max_packet_size(); +} +inline ::google::protobuf::uint32 RPCMethodConfig::max_packet_size() const { + // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.max_packet_size) + return max_packet_size_; +} +inline void RPCMethodConfig::set_max_packet_size(::google::protobuf::uint32 value) { + set_has_max_packet_size(); + max_packet_size_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.max_packet_size) +} + +// optional uint32 max_encoded_size = 10; +inline bool RPCMethodConfig::has_max_encoded_size() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +inline void RPCMethodConfig::set_has_max_encoded_size() { + _has_bits_[0] |= 0x00000200u; +} +inline void RPCMethodConfig::clear_has_max_encoded_size() { + _has_bits_[0] &= ~0x00000200u; +} +inline void RPCMethodConfig::clear_max_encoded_size() { + max_encoded_size_ = 0u; + clear_has_max_encoded_size(); +} +inline ::google::protobuf::uint32 RPCMethodConfig::max_encoded_size() const { + // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.max_encoded_size) + return max_encoded_size_; +} +inline void RPCMethodConfig::set_max_encoded_size(::google::protobuf::uint32 value) { + set_has_max_encoded_size(); + max_encoded_size_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.max_encoded_size) +} + +// optional float timeout = 11; +inline bool RPCMethodConfig::has_timeout() const { + return (_has_bits_[0] & 0x00000400u) != 0; +} +inline void RPCMethodConfig::set_has_timeout() { + _has_bits_[0] |= 0x00000400u; +} +inline void RPCMethodConfig::clear_has_timeout() { + _has_bits_[0] &= ~0x00000400u; +} +inline void RPCMethodConfig::clear_timeout() { + timeout_ = 0; + clear_has_timeout(); +} +inline float RPCMethodConfig::timeout() const { + // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.timeout) + return timeout_; +} +inline void RPCMethodConfig::set_timeout(float value) { + set_has_timeout(); + timeout_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.timeout) +} + +// optional uint32 cap_balance = 12; +inline bool RPCMethodConfig::has_cap_balance() const { + return (_has_bits_[0] & 0x00000800u) != 0; +} +inline void RPCMethodConfig::set_has_cap_balance() { + _has_bits_[0] |= 0x00000800u; +} +inline void RPCMethodConfig::clear_has_cap_balance() { + _has_bits_[0] &= ~0x00000800u; +} +inline void RPCMethodConfig::clear_cap_balance() { + cap_balance_ = 0u; + clear_has_cap_balance(); +} +inline ::google::protobuf::uint32 RPCMethodConfig::cap_balance() const { + // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.cap_balance) + return cap_balance_; +} +inline void RPCMethodConfig::set_cap_balance(::google::protobuf::uint32 value) { + set_has_cap_balance(); + cap_balance_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.cap_balance) +} + +// optional float income_per_second = 13 [default = 0]; +inline bool RPCMethodConfig::has_income_per_second() const { + return (_has_bits_[0] & 0x00001000u) != 0; +} +inline void RPCMethodConfig::set_has_income_per_second() { + _has_bits_[0] |= 0x00001000u; +} +inline void RPCMethodConfig::clear_has_income_per_second() { + _has_bits_[0] &= ~0x00001000u; +} +inline void RPCMethodConfig::clear_income_per_second() { + income_per_second_ = 0; + clear_has_income_per_second(); +} +inline float RPCMethodConfig::income_per_second() const { + // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.income_per_second) + return income_per_second_; +} +inline void RPCMethodConfig::set_income_per_second(float value) { + set_has_income_per_second(); + income_per_second_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.income_per_second) +} + +// optional uint32 service_hash = 14; +inline bool RPCMethodConfig::has_service_hash() const { + return (_has_bits_[0] & 0x00002000u) != 0; +} +inline void RPCMethodConfig::set_has_service_hash() { + _has_bits_[0] |= 0x00002000u; +} +inline void RPCMethodConfig::clear_has_service_hash() { + _has_bits_[0] &= ~0x00002000u; +} +inline void RPCMethodConfig::clear_service_hash() { + service_hash_ = 0u; + clear_has_service_hash(); +} +inline ::google::protobuf::uint32 RPCMethodConfig::service_hash() const { + // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.service_hash) + return service_hash_; +} +inline void RPCMethodConfig::set_service_hash(::google::protobuf::uint32 value) { + set_has_service_hash(); + service_hash_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.service_hash) +} + +// optional uint32 method_id = 15; +inline bool RPCMethodConfig::has_method_id() const { + return (_has_bits_[0] & 0x00004000u) != 0; +} +inline void RPCMethodConfig::set_has_method_id() { + _has_bits_[0] |= 0x00004000u; +} +inline void RPCMethodConfig::clear_has_method_id() { + _has_bits_[0] &= ~0x00004000u; +} +inline void RPCMethodConfig::clear_method_id() { + method_id_ = 0u; + clear_has_method_id(); +} +inline ::google::protobuf::uint32 RPCMethodConfig::method_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.method_id) + return method_id_; +} +inline void RPCMethodConfig::set_method_id(::google::protobuf::uint32 value) { + set_has_method_id(); + method_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.method_id) +} + +// ------------------------------------------------------------------- + +// RPCMeterConfig + +// repeated .bgs.protocol.config.RPCMethodConfig method = 1; +inline int RPCMeterConfig::method_size() const { + return method_.size(); +} +inline void RPCMeterConfig::clear_method() { + method_.Clear(); +} +inline const ::bgs::protocol::config::RPCMethodConfig& RPCMeterConfig::method(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMeterConfig.method) + return method_.Get(index); +} +inline ::bgs::protocol::config::RPCMethodConfig* RPCMeterConfig::mutable_method(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.config.RPCMeterConfig.method) + return method_.Mutable(index); +} +inline ::bgs::protocol::config::RPCMethodConfig* RPCMeterConfig::add_method() { + // @@protoc_insertion_point(field_add:bgs.protocol.config.RPCMeterConfig.method) + return method_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::config::RPCMethodConfig >& +RPCMeterConfig::method() const { + // @@protoc_insertion_point(field_list:bgs.protocol.config.RPCMeterConfig.method) + return method_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::config::RPCMethodConfig >* +RPCMeterConfig::mutable_method() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.config.RPCMeterConfig.method) + return &method_; +} + +// optional uint32 income_per_second = 2 [default = 1]; +inline bool RPCMeterConfig::has_income_per_second() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void RPCMeterConfig::set_has_income_per_second() { + _has_bits_[0] |= 0x00000002u; +} +inline void RPCMeterConfig::clear_has_income_per_second() { + _has_bits_[0] &= ~0x00000002u; +} +inline void RPCMeterConfig::clear_income_per_second() { + income_per_second_ = 1u; + clear_has_income_per_second(); +} +inline ::google::protobuf::uint32 RPCMeterConfig::income_per_second() const { + // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMeterConfig.income_per_second) + return income_per_second_; +} +inline void RPCMeterConfig::set_income_per_second(::google::protobuf::uint32 value) { + set_has_income_per_second(); + income_per_second_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMeterConfig.income_per_second) +} + +// optional uint32 initial_balance = 3; +inline bool RPCMeterConfig::has_initial_balance() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void RPCMeterConfig::set_has_initial_balance() { + _has_bits_[0] |= 0x00000004u; +} +inline void RPCMeterConfig::clear_has_initial_balance() { + _has_bits_[0] &= ~0x00000004u; +} +inline void RPCMeterConfig::clear_initial_balance() { + initial_balance_ = 0u; + clear_has_initial_balance(); +} +inline ::google::protobuf::uint32 RPCMeterConfig::initial_balance() const { + // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMeterConfig.initial_balance) + return initial_balance_; +} +inline void RPCMeterConfig::set_initial_balance(::google::protobuf::uint32 value) { + set_has_initial_balance(); + initial_balance_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMeterConfig.initial_balance) +} + +// optional uint32 cap_balance = 4; +inline bool RPCMeterConfig::has_cap_balance() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void RPCMeterConfig::set_has_cap_balance() { + _has_bits_[0] |= 0x00000008u; +} +inline void RPCMeterConfig::clear_has_cap_balance() { + _has_bits_[0] &= ~0x00000008u; +} +inline void RPCMeterConfig::clear_cap_balance() { + cap_balance_ = 0u; + clear_has_cap_balance(); +} +inline ::google::protobuf::uint32 RPCMeterConfig::cap_balance() const { + // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMeterConfig.cap_balance) + return cap_balance_; +} +inline void RPCMeterConfig::set_cap_balance(::google::protobuf::uint32 value) { + set_has_cap_balance(); + cap_balance_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMeterConfig.cap_balance) +} + +// optional float startup_period = 5 [default = 0]; +inline bool RPCMeterConfig::has_startup_period() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void RPCMeterConfig::set_has_startup_period() { + _has_bits_[0] |= 0x00000010u; +} +inline void RPCMeterConfig::clear_has_startup_period() { + _has_bits_[0] &= ~0x00000010u; +} +inline void RPCMeterConfig::clear_startup_period() { + startup_period_ = 0; + clear_has_startup_period(); +} +inline float RPCMeterConfig::startup_period() const { + // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMeterConfig.startup_period) + return startup_period_; +} +inline void RPCMeterConfig::set_startup_period(float value) { + set_has_startup_period(); + startup_period_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMeterConfig.startup_period) +} + +// ------------------------------------------------------------------- + +// ProtocolAlias + +// required string server_service_name = 1; +inline bool ProtocolAlias::has_server_service_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ProtocolAlias::set_has_server_service_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void ProtocolAlias::clear_has_server_service_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ProtocolAlias::clear_server_service_name() { + if (server_service_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + server_service_name_->clear(); + } + clear_has_server_service_name(); +} +inline const ::std::string& ProtocolAlias::server_service_name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.config.ProtocolAlias.server_service_name) + return *server_service_name_; +} +inline void ProtocolAlias::set_server_service_name(const ::std::string& value) { + set_has_server_service_name(); + if (server_service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + server_service_name_ = new ::std::string; + } + server_service_name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.config.ProtocolAlias.server_service_name) +} +inline void ProtocolAlias::set_server_service_name(const char* value) { + set_has_server_service_name(); + if (server_service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + server_service_name_ = new ::std::string; + } + server_service_name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.config.ProtocolAlias.server_service_name) +} +inline void ProtocolAlias::set_server_service_name(const char* value, size_t size) { + set_has_server_service_name(); + if (server_service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + server_service_name_ = new ::std::string; + } + server_service_name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.config.ProtocolAlias.server_service_name) +} +inline ::std::string* ProtocolAlias::mutable_server_service_name() { + set_has_server_service_name(); + if (server_service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + server_service_name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.config.ProtocolAlias.server_service_name) + return server_service_name_; +} +inline ::std::string* ProtocolAlias::release_server_service_name() { + clear_has_server_service_name(); + if (server_service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = server_service_name_; + server_service_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ProtocolAlias::set_allocated_server_service_name(::std::string* server_service_name) { + if (server_service_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete server_service_name_; + } + if (server_service_name) { + set_has_server_service_name(); + server_service_name_ = server_service_name; + } else { + clear_has_server_service_name(); + server_service_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.config.ProtocolAlias.server_service_name) +} + +// required string client_service_name = 2; +inline bool ProtocolAlias::has_client_service_name() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ProtocolAlias::set_has_client_service_name() { + _has_bits_[0] |= 0x00000002u; +} +inline void ProtocolAlias::clear_has_client_service_name() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ProtocolAlias::clear_client_service_name() { + if (client_service_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_service_name_->clear(); + } + clear_has_client_service_name(); +} +inline const ::std::string& ProtocolAlias::client_service_name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.config.ProtocolAlias.client_service_name) + return *client_service_name_; +} +inline void ProtocolAlias::set_client_service_name(const ::std::string& value) { + set_has_client_service_name(); + if (client_service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_service_name_ = new ::std::string; + } + client_service_name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.config.ProtocolAlias.client_service_name) +} +inline void ProtocolAlias::set_client_service_name(const char* value) { + set_has_client_service_name(); + if (client_service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_service_name_ = new ::std::string; + } + client_service_name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.config.ProtocolAlias.client_service_name) +} +inline void ProtocolAlias::set_client_service_name(const char* value, size_t size) { + set_has_client_service_name(); + if (client_service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_service_name_ = new ::std::string; + } + client_service_name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.config.ProtocolAlias.client_service_name) +} +inline ::std::string* ProtocolAlias::mutable_client_service_name() { + set_has_client_service_name(); + if (client_service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + client_service_name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.config.ProtocolAlias.client_service_name) + return client_service_name_; +} +inline ::std::string* ProtocolAlias::release_client_service_name() { + clear_has_client_service_name(); + if (client_service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = client_service_name_; + client_service_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void ProtocolAlias::set_allocated_client_service_name(::std::string* client_service_name) { + if (client_service_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete client_service_name_; + } + if (client_service_name) { + set_has_client_service_name(); + client_service_name_ = client_service_name; + } else { + clear_has_client_service_name(); + client_service_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.config.ProtocolAlias.client_service_name) +} + +// ------------------------------------------------------------------- + +// ServiceAliases + +// repeated .bgs.protocol.config.ProtocolAlias protocol_alias = 1; +inline int ServiceAliases::protocol_alias_size() const { + return protocol_alias_.size(); +} +inline void ServiceAliases::clear_protocol_alias() { + protocol_alias_.Clear(); +} +inline const ::bgs::protocol::config::ProtocolAlias& ServiceAliases::protocol_alias(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.config.ServiceAliases.protocol_alias) + return protocol_alias_.Get(index); +} +inline ::bgs::protocol::config::ProtocolAlias* ServiceAliases::mutable_protocol_alias(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.config.ServiceAliases.protocol_alias) + return protocol_alias_.Mutable(index); +} +inline ::bgs::protocol::config::ProtocolAlias* ServiceAliases::add_protocol_alias() { + // @@protoc_insertion_point(field_add:bgs.protocol.config.ServiceAliases.protocol_alias) + return protocol_alias_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::config::ProtocolAlias >& +ServiceAliases::protocol_alias() const { + // @@protoc_insertion_point(field_list:bgs.protocol.config.ServiceAliases.protocol_alias) + return protocol_alias_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::config::ProtocolAlias >* +ServiceAliases::mutable_protocol_alias() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.config.ServiceAliases.protocol_alias) + return &protocol_alias_; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace config +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_rpc_5fconfig_2eproto__INCLUDED diff --git a/src/server/proto/Client/rpc_types.pb.cc b/src/server/proto/Client/rpc_types.pb.cc new file mode 100644 index 00000000000..7eb6c798906 --- /dev/null +++ b/src/server/proto/Client/rpc_types.pb.cc @@ -0,0 +1,2460 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: rpc_types.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "rpc_types.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { + +namespace { + +const ::google::protobuf::Descriptor* NO_RESPONSE_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + NO_RESPONSE_reflection_ = NULL; +const ::google::protobuf::Descriptor* Address_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Address_reflection_ = NULL; +const ::google::protobuf::Descriptor* ProcessId_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ProcessId_reflection_ = NULL; +const ::google::protobuf::Descriptor* ObjectAddress_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ObjectAddress_reflection_ = NULL; +const ::google::protobuf::Descriptor* NoData_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + NoData_reflection_ = NULL; +const ::google::protobuf::Descriptor* ErrorInfo_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ErrorInfo_reflection_ = NULL; +const ::google::protobuf::Descriptor* Header_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Header_reflection_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_rpc_5ftypes_2eproto() { + protobuf_AddDesc_rpc_5ftypes_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "rpc_types.proto"); + GOOGLE_CHECK(file != NULL); + NO_RESPONSE_descriptor_ = file->message_type(0); + static const int NO_RESPONSE_offsets_[1] = { + }; + NO_RESPONSE_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + NO_RESPONSE_descriptor_, + NO_RESPONSE::default_instance_, + NO_RESPONSE_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NO_RESPONSE, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NO_RESPONSE, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(NO_RESPONSE)); + Address_descriptor_ = file->message_type(1); + static const int Address_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Address, address_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Address, port_), + }; + Address_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Address_descriptor_, + Address::default_instance_, + Address_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Address, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Address, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Address)); + ProcessId_descriptor_ = file->message_type(2); + static const int ProcessId_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessId, label_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessId, epoch_), + }; + ProcessId_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ProcessId_descriptor_, + ProcessId::default_instance_, + ProcessId_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessId, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessId, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ProcessId)); + ObjectAddress_descriptor_ = file->message_type(3); + static const int ObjectAddress_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectAddress, host_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectAddress, object_id_), + }; + ObjectAddress_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ObjectAddress_descriptor_, + ObjectAddress::default_instance_, + ObjectAddress_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectAddress, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectAddress, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ObjectAddress)); + NoData_descriptor_ = file->message_type(4); + static const int NoData_offsets_[1] = { + }; + NoData_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + NoData_descriptor_, + NoData::default_instance_, + NoData_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NoData, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NoData, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(NoData)); + ErrorInfo_descriptor_ = file->message_type(5); + static const int ErrorInfo_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ErrorInfo, object_address_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ErrorInfo, status_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ErrorInfo, service_hash_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ErrorInfo, method_id_), + }; + ErrorInfo_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ErrorInfo_descriptor_, + ErrorInfo::default_instance_, + ErrorInfo_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ErrorInfo, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ErrorInfo, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ErrorInfo)); + Header_descriptor_ = file->message_type(6); + static const int Header_offsets_[11] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, service_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, method_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, token_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, object_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, status_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, error_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, timeout_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, is_response_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, forward_targets_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, service_hash_), + }; + Header_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Header_descriptor_, + Header::default_instance_, + Header_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Header)); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_rpc_5ftypes_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + NO_RESPONSE_descriptor_, &NO_RESPONSE::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Address_descriptor_, &Address::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ProcessId_descriptor_, &ProcessId::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ObjectAddress_descriptor_, &ObjectAddress::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + NoData_descriptor_, &NoData::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ErrorInfo_descriptor_, &ErrorInfo::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Header_descriptor_, &Header::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_rpc_5ftypes_2eproto() { + delete NO_RESPONSE::default_instance_; + delete NO_RESPONSE_reflection_; + delete Address::default_instance_; + delete Address_reflection_; + delete ProcessId::default_instance_; + delete ProcessId_reflection_; + delete ObjectAddress::default_instance_; + delete ObjectAddress_reflection_; + delete NoData::default_instance_; + delete NoData_reflection_; + delete ErrorInfo::default_instance_; + delete ErrorInfo_reflection_; + delete Header::default_instance_; + delete Header_reflection_; +} + +void protobuf_AddDesc_rpc_5ftypes_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::bgs::protocol::protobuf_AddDesc_global_5fextensions_2fmethod_5foptions_2eproto(); + ::bgs::protocol::protobuf_AddDesc_global_5fextensions_2fservice_5foptions_2eproto(); + ::bgs::protocol::protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\017rpc_types.proto\022\014bgs.protocol\032&global_" + "extensions/method_options.proto\032\'global_" + "extensions/service_options.proto\032%global" + "_extensions/field_options.proto\"\r\n\013NO_RE" + "SPONSE\"(\n\007Address\022\017\n\007address\030\001 \002(\t\022\014\n\004po" + "rt\030\002 \001(\r\")\n\tProcessId\022\r\n\005label\030\001 \002(\r\022\r\n\005" + "epoch\030\002 \002(\r\"L\n\rObjectAddress\022%\n\004host\030\001 \002" + "(\0132\027.bgs.protocol.ProcessId\022\024\n\tobject_id" + "\030\002 \001(\004:\0010\"\010\n\006NoData\"y\n\tErrorInfo\0223\n\016obje" + "ct_address\030\001 \002(\0132\033.bgs.protocol.ObjectAd" + "dress\022\016\n\006status\030\002 \002(\r\022\024\n\014service_hash\030\003 " + "\002(\r\022\021\n\tmethod_id\030\004 \002(\r\"\216\002\n\006Header\022\022\n\nser" + "vice_id\030\001 \002(\r\022\021\n\tmethod_id\030\002 \001(\r\022\r\n\005toke" + "n\030\003 \002(\r\022\024\n\tobject_id\030\004 \001(\004:\0010\022\017\n\004size\030\005 " + "\001(\r:\0010\022\021\n\006status\030\006 \001(\r:\0010\022&\n\005error\030\007 \003(\013" + "2\027.bgs.protocol.ErrorInfo\022\017\n\007timeout\030\010 \001" + "(\004\022\023\n\013is_response\030\t \001(\010\0220\n\017forward_targe" + "ts\030\n \003(\0132\027.bgs.protocol.ProcessId\022\024\n\014ser" + "vice_hash\030\013 \001(\007B\033\n\rbnet.protocolB\010RpcPro" + "toH\001P\000P\001P\002", 770); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "rpc_types.proto", &protobuf_RegisterTypes); + NO_RESPONSE::default_instance_ = new NO_RESPONSE(); + Address::default_instance_ = new Address(); + ProcessId::default_instance_ = new ProcessId(); + ObjectAddress::default_instance_ = new ObjectAddress(); + NoData::default_instance_ = new NoData(); + ErrorInfo::default_instance_ = new ErrorInfo(); + Header::default_instance_ = new Header(); + NO_RESPONSE::default_instance_->InitAsDefaultInstance(); + Address::default_instance_->InitAsDefaultInstance(); + ProcessId::default_instance_->InitAsDefaultInstance(); + ObjectAddress::default_instance_->InitAsDefaultInstance(); + NoData::default_instance_->InitAsDefaultInstance(); + ErrorInfo::default_instance_->InitAsDefaultInstance(); + Header::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_rpc_5ftypes_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_rpc_5ftypes_2eproto { + StaticDescriptorInitializer_rpc_5ftypes_2eproto() { + protobuf_AddDesc_rpc_5ftypes_2eproto(); + } +} static_descriptor_initializer_rpc_5ftypes_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +#endif // !_MSC_VER + +NO_RESPONSE::NO_RESPONSE() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.NO_RESPONSE) +} + +void NO_RESPONSE::InitAsDefaultInstance() { +} + +NO_RESPONSE::NO_RESPONSE(const NO_RESPONSE& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.NO_RESPONSE) +} + +void NO_RESPONSE::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +NO_RESPONSE::~NO_RESPONSE() { + // @@protoc_insertion_point(destructor:bgs.protocol.NO_RESPONSE) + SharedDtor(); +} + +void NO_RESPONSE::SharedDtor() { + if (this != default_instance_) { + } +} + +void NO_RESPONSE::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* NO_RESPONSE::descriptor() { + protobuf_AssignDescriptorsOnce(); + return NO_RESPONSE_descriptor_; +} + +const NO_RESPONSE& NO_RESPONSE::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_rpc_5ftypes_2eproto(); + return *default_instance_; +} + +NO_RESPONSE* NO_RESPONSE::default_instance_ = NULL; + +NO_RESPONSE* NO_RESPONSE::New() const { + return new NO_RESPONSE; +} + +void NO_RESPONSE::Clear() { + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool NO_RESPONSE::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.NO_RESPONSE) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + 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())); + } +success: + // @@protoc_insertion_point(parse_success:bgs.protocol.NO_RESPONSE) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.NO_RESPONSE) + return false; +#undef DO_ +} + +void NO_RESPONSE::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.NO_RESPONSE) + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.NO_RESPONSE) +} + +::google::protobuf::uint8* NO_RESPONSE::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.NO_RESPONSE) + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.NO_RESPONSE) + return target; +} + +int NO_RESPONSE::ByteSize() const { + int total_size = 0; + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void NO_RESPONSE::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const NO_RESPONSE* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void NO_RESPONSE::MergeFrom(const NO_RESPONSE& from) { + GOOGLE_CHECK_NE(&from, this); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void NO_RESPONSE::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void NO_RESPONSE::CopyFrom(const NO_RESPONSE& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool NO_RESPONSE::IsInitialized() const { + + return true; +} + +void NO_RESPONSE::Swap(NO_RESPONSE* other) { + if (other != this) { + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata NO_RESPONSE::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = NO_RESPONSE_descriptor_; + metadata.reflection = NO_RESPONSE_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int Address::kAddressFieldNumber; +const int Address::kPortFieldNumber; +#endif // !_MSC_VER + +Address::Address() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.Address) +} + +void Address::InitAsDefaultInstance() { +} + +Address::Address(const Address& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.Address) +} + +void Address::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + port_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Address::~Address() { + // @@protoc_insertion_point(destructor:bgs.protocol.Address) + SharedDtor(); +} + +void Address::SharedDtor() { + if (address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete address_; + } + if (this != default_instance_) { + } +} + +void Address::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Address::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Address_descriptor_; +} + +const Address& Address::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_rpc_5ftypes_2eproto(); + return *default_instance_; +} + +Address* Address::default_instance_ = NULL; + +Address* Address::New() const { + return new Address; +} + +void Address::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_address()) { + if (address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + address_->clear(); + } + } + port_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Address::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.Address) + 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)) { + // required string address = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_address())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->address().data(), this->address().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "address"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_port; + break; + } + + // optional uint32 port = 2; + case 2: { + if (tag == 16) { + parse_port: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &port_))); + set_has_port(); + } 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:bgs.protocol.Address) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.Address) + return false; +#undef DO_ +} + +void Address::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.Address) + // required string address = 1; + if (has_address()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->address().data(), this->address().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "address"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->address(), output); + } + + // optional uint32 port = 2; + if (has_port()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->port(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.Address) +} + +::google::protobuf::uint8* Address::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.Address) + // required string address = 1; + if (has_address()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->address().data(), this->address().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "address"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->address(), target); + } + + // optional uint32 port = 2; + if (has_port()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->port(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.Address) + return target; +} + +int Address::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string address = 1; + if (has_address()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->address()); + } + + // optional uint32 port = 2; + if (has_port()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->port()); + } + + } + 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 Address::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Address* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Address::MergeFrom(const Address& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_address()) { + set_address(from.address()); + } + if (from.has_port()) { + set_port(from.port()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Address::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Address::CopyFrom(const Address& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Address::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void Address::Swap(Address* other) { + if (other != this) { + std::swap(address_, other->address_); + std::swap(port_, other->port_); + 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 Address::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Address_descriptor_; + metadata.reflection = Address_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ProcessId::kLabelFieldNumber; +const int ProcessId::kEpochFieldNumber; +#endif // !_MSC_VER + +ProcessId::ProcessId() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.ProcessId) +} + +void ProcessId::InitAsDefaultInstance() { +} + +ProcessId::ProcessId(const ProcessId& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.ProcessId) +} + +void ProcessId::SharedCtor() { + _cached_size_ = 0; + label_ = 0u; + epoch_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ProcessId::~ProcessId() { + // @@protoc_insertion_point(destructor:bgs.protocol.ProcessId) + SharedDtor(); +} + +void ProcessId::SharedDtor() { + if (this != default_instance_) { + } +} + +void ProcessId::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ProcessId::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ProcessId_descriptor_; +} + +const ProcessId& ProcessId::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_rpc_5ftypes_2eproto(); + return *default_instance_; +} + +ProcessId* ProcessId::default_instance_ = NULL; + +ProcessId* ProcessId::New() const { + return new ProcessId; +} + +void ProcessId::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(label_, epoch_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ProcessId::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.ProcessId) + 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)) { + // required uint32 label = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &label_))); + set_has_label(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_epoch; + break; + } + + // required uint32 epoch = 2; + case 2: { + if (tag == 16) { + parse_epoch: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &epoch_))); + set_has_epoch(); + } 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:bgs.protocol.ProcessId) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.ProcessId) + return false; +#undef DO_ +} + +void ProcessId::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.ProcessId) + // required uint32 label = 1; + if (has_label()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->label(), output); + } + + // required uint32 epoch = 2; + if (has_epoch()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->epoch(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.ProcessId) +} + +::google::protobuf::uint8* ProcessId::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.ProcessId) + // required uint32 label = 1; + if (has_label()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->label(), target); + } + + // required uint32 epoch = 2; + if (has_epoch()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->epoch(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.ProcessId) + return target; +} + +int ProcessId::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required uint32 label = 1; + if (has_label()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->label()); + } + + // required uint32 epoch = 2; + if (has_epoch()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->epoch()); + } + + } + 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 ProcessId::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ProcessId* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ProcessId::MergeFrom(const ProcessId& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_label()) { + set_label(from.label()); + } + if (from.has_epoch()) { + set_epoch(from.epoch()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ProcessId::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ProcessId::CopyFrom(const ProcessId& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ProcessId::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void ProcessId::Swap(ProcessId* other) { + if (other != this) { + std::swap(label_, other->label_); + std::swap(epoch_, other->epoch_); + 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 ProcessId::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ProcessId_descriptor_; + metadata.reflection = ProcessId_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ObjectAddress::kHostFieldNumber; +const int ObjectAddress::kObjectIdFieldNumber; +#endif // !_MSC_VER + +ObjectAddress::ObjectAddress() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.ObjectAddress) +} + +void ObjectAddress::InitAsDefaultInstance() { + host_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance()); +} + +ObjectAddress::ObjectAddress(const ObjectAddress& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.ObjectAddress) +} + +void ObjectAddress::SharedCtor() { + _cached_size_ = 0; + host_ = NULL; + object_id_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ObjectAddress::~ObjectAddress() { + // @@protoc_insertion_point(destructor:bgs.protocol.ObjectAddress) + SharedDtor(); +} + +void ObjectAddress::SharedDtor() { + if (this != default_instance_) { + delete host_; + } +} + +void ObjectAddress::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ObjectAddress::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ObjectAddress_descriptor_; +} + +const ObjectAddress& ObjectAddress::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_rpc_5ftypes_2eproto(); + return *default_instance_; +} + +ObjectAddress* ObjectAddress::default_instance_ = NULL; + +ObjectAddress* ObjectAddress::New() const { + return new ObjectAddress; +} + +void ObjectAddress::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_host()) { + if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear(); + } + object_id_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ObjectAddress::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.ObjectAddress) + 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)) { + // required .bgs.protocol.ProcessId host = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_host())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_object_id; + break; + } + + // optional uint64 object_id = 2 [default = 0]; + case 2: { + if (tag == 16) { + parse_object_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &object_id_))); + set_has_object_id(); + } 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:bgs.protocol.ObjectAddress) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.ObjectAddress) + return false; +#undef DO_ +} + +void ObjectAddress::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.ObjectAddress) + // required .bgs.protocol.ProcessId host = 1; + if (has_host()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->host(), output); + } + + // optional uint64 object_id = 2 [default = 0]; + if (has_object_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->object_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.ObjectAddress) +} + +::google::protobuf::uint8* ObjectAddress::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.ObjectAddress) + // required .bgs.protocol.ProcessId host = 1; + if (has_host()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->host(), target); + } + + // optional uint64 object_id = 2 [default = 0]; + if (has_object_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->object_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.ObjectAddress) + return target; +} + +int ObjectAddress::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.ProcessId host = 1; + if (has_host()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->host()); + } + + // optional uint64 object_id = 2 [default = 0]; + if (has_object_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->object_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ObjectAddress::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ObjectAddress* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ObjectAddress::MergeFrom(const ObjectAddress& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_host()) { + mutable_host()->::bgs::protocol::ProcessId::MergeFrom(from.host()); + } + if (from.has_object_id()) { + set_object_id(from.object_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ObjectAddress::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ObjectAddress::CopyFrom(const ObjectAddress& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ObjectAddress::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_host()) { + if (!this->host().IsInitialized()) return false; + } + return true; +} + +void ObjectAddress::Swap(ObjectAddress* other) { + if (other != this) { + std::swap(host_, other->host_); + std::swap(object_id_, other->object_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata ObjectAddress::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ObjectAddress_descriptor_; + metadata.reflection = ObjectAddress_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +#endif // !_MSC_VER + +NoData::NoData() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.NoData) +} + +void NoData::InitAsDefaultInstance() { +} + +NoData::NoData(const NoData& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.NoData) +} + +void NoData::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +NoData::~NoData() { + // @@protoc_insertion_point(destructor:bgs.protocol.NoData) + SharedDtor(); +} + +void NoData::SharedDtor() { + if (this != default_instance_) { + } +} + +void NoData::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* NoData::descriptor() { + protobuf_AssignDescriptorsOnce(); + return NoData_descriptor_; +} + +const NoData& NoData::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_rpc_5ftypes_2eproto(); + return *default_instance_; +} + +NoData* NoData::default_instance_ = NULL; + +NoData* NoData::New() const { + return new NoData; +} + +void NoData::Clear() { + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool NoData::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.NoData) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + 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())); + } +success: + // @@protoc_insertion_point(parse_success:bgs.protocol.NoData) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.NoData) + return false; +#undef DO_ +} + +void NoData::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.NoData) + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.NoData) +} + +::google::protobuf::uint8* NoData::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.NoData) + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.NoData) + return target; +} + +int NoData::ByteSize() const { + int total_size = 0; + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void NoData::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const NoData* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void NoData::MergeFrom(const NoData& from) { + GOOGLE_CHECK_NE(&from, this); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void NoData::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void NoData::CopyFrom(const NoData& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool NoData::IsInitialized() const { + + return true; +} + +void NoData::Swap(NoData* other) { + if (other != this) { + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata NoData::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = NoData_descriptor_; + metadata.reflection = NoData_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ErrorInfo::kObjectAddressFieldNumber; +const int ErrorInfo::kStatusFieldNumber; +const int ErrorInfo::kServiceHashFieldNumber; +const int ErrorInfo::kMethodIdFieldNumber; +#endif // !_MSC_VER + +ErrorInfo::ErrorInfo() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.ErrorInfo) +} + +void ErrorInfo::InitAsDefaultInstance() { + object_address_ = const_cast< ::bgs::protocol::ObjectAddress*>(&::bgs::protocol::ObjectAddress::default_instance()); +} + +ErrorInfo::ErrorInfo(const ErrorInfo& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.ErrorInfo) +} + +void ErrorInfo::SharedCtor() { + _cached_size_ = 0; + object_address_ = NULL; + status_ = 0u; + service_hash_ = 0u; + method_id_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ErrorInfo::~ErrorInfo() { + // @@protoc_insertion_point(destructor:bgs.protocol.ErrorInfo) + SharedDtor(); +} + +void ErrorInfo::SharedDtor() { + if (this != default_instance_) { + delete object_address_; + } +} + +void ErrorInfo::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ErrorInfo::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ErrorInfo_descriptor_; +} + +const ErrorInfo& ErrorInfo::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_rpc_5ftypes_2eproto(); + return *default_instance_; +} + +ErrorInfo* ErrorInfo::default_instance_ = NULL; + +ErrorInfo* ErrorInfo::New() const { + return new ErrorInfo; +} + +void ErrorInfo::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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_(status_, method_id_); + if (has_object_address()) { + if (object_address_ != NULL) object_address_->::bgs::protocol::ObjectAddress::Clear(); + } + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ErrorInfo::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.ErrorInfo) + 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)) { + // required .bgs.protocol.ObjectAddress object_address = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_object_address())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_status; + break; + } + + // required uint32 status = 2; + case 2: { + if (tag == 16) { + parse_status: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &status_))); + set_has_status(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_service_hash; + break; + } + + // required uint32 service_hash = 3; + case 3: { + if (tag == 24) { + parse_service_hash: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &service_hash_))); + set_has_service_hash(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_method_id; + break; + } + + // required uint32 method_id = 4; + case 4: { + if (tag == 32) { + parse_method_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &method_id_))); + set_has_method_id(); + } 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:bgs.protocol.ErrorInfo) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.ErrorInfo) + return false; +#undef DO_ +} + +void ErrorInfo::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.ErrorInfo) + // required .bgs.protocol.ObjectAddress object_address = 1; + if (has_object_address()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->object_address(), output); + } + + // required uint32 status = 2; + if (has_status()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->status(), output); + } + + // required uint32 service_hash = 3; + if (has_service_hash()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->service_hash(), output); + } + + // required uint32 method_id = 4; + if (has_method_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->method_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.ErrorInfo) +} + +::google::protobuf::uint8* ErrorInfo::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.ErrorInfo) + // required .bgs.protocol.ObjectAddress object_address = 1; + if (has_object_address()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->object_address(), target); + } + + // required uint32 status = 2; + if (has_status()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->status(), target); + } + + // required uint32 service_hash = 3; + if (has_service_hash()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->service_hash(), target); + } + + // required uint32 method_id = 4; + if (has_method_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->method_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.ErrorInfo) + return target; +} + +int ErrorInfo::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.ObjectAddress object_address = 1; + if (has_object_address()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->object_address()); + } + + // required uint32 status = 2; + if (has_status()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->status()); + } + + // required uint32 service_hash = 3; + if (has_service_hash()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->service_hash()); + } + + // required uint32 method_id = 4; + if (has_method_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->method_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ErrorInfo::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ErrorInfo* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ErrorInfo::MergeFrom(const ErrorInfo& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_object_address()) { + mutable_object_address()->::bgs::protocol::ObjectAddress::MergeFrom(from.object_address()); + } + if (from.has_status()) { + set_status(from.status()); + } + if (from.has_service_hash()) { + set_service_hash(from.service_hash()); + } + if (from.has_method_id()) { + set_method_id(from.method_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ErrorInfo::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ErrorInfo::CopyFrom(const ErrorInfo& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ErrorInfo::IsInitialized() const { + if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false; + + if (has_object_address()) { + if (!this->object_address().IsInitialized()) return false; + } + return true; +} + +void ErrorInfo::Swap(ErrorInfo* other) { + if (other != this) { + std::swap(object_address_, other->object_address_); + std::swap(status_, other->status_); + std::swap(service_hash_, other->service_hash_); + std::swap(method_id_, other->method_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata ErrorInfo::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ErrorInfo_descriptor_; + metadata.reflection = ErrorInfo_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int Header::kServiceIdFieldNumber; +const int Header::kMethodIdFieldNumber; +const int Header::kTokenFieldNumber; +const int Header::kObjectIdFieldNumber; +const int Header::kSizeFieldNumber; +const int Header::kStatusFieldNumber; +const int Header::kErrorFieldNumber; +const int Header::kTimeoutFieldNumber; +const int Header::kIsResponseFieldNumber; +const int Header::kForwardTargetsFieldNumber; +const int Header::kServiceHashFieldNumber; +#endif // !_MSC_VER + +Header::Header() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.Header) +} + +void Header::InitAsDefaultInstance() { +} + +Header::Header(const Header& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.Header) +} + +void Header::SharedCtor() { + _cached_size_ = 0; + service_id_ = 0u; + method_id_ = 0u; + token_ = 0u; + object_id_ = GOOGLE_ULONGLONG(0); + size_ = 0u; + status_ = 0u; + timeout_ = GOOGLE_ULONGLONG(0); + is_response_ = false; + service_hash_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Header::~Header() { + // @@protoc_insertion_point(destructor:bgs.protocol.Header) + SharedDtor(); +} + +void Header::SharedDtor() { + if (this != default_instance_) { + } +} + +void Header::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Header::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Header_descriptor_; +} + +const Header& Header::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_rpc_5ftypes_2eproto(); + return *default_instance_; +} + +Header* Header::default_instance_ = NULL; + +Header* Header::New() const { + return new Header; +} + +void Header::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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] & 191) { + ZR_(service_id_, size_); + status_ = 0u; + timeout_ = GOOGLE_ULONGLONG(0); + } + if (_has_bits_[8 / 32] & 1280) { + is_response_ = false; + service_hash_ = 0u; + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + error_.Clear(); + forward_targets_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Header::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.Header) + 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)) { + // required uint32 service_id = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &service_id_))); + set_has_service_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_method_id; + break; + } + + // optional uint32 method_id = 2; + case 2: { + if (tag == 16) { + parse_method_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &method_id_))); + set_has_method_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_token; + break; + } + + // required uint32 token = 3; + case 3: { + if (tag == 24) { + parse_token: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &token_))); + set_has_token(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_object_id; + break; + } + + // optional uint64 object_id = 4 [default = 0]; + case 4: { + if (tag == 32) { + parse_object_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &object_id_))); + set_has_object_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(40)) goto parse_size; + break; + } + + // optional uint32 size = 5 [default = 0]; + case 5: { + if (tag == 40) { + parse_size: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &size_))); + set_has_size(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(48)) goto parse_status; + break; + } + + // optional uint32 status = 6 [default = 0]; + case 6: { + if (tag == 48) { + parse_status: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &status_))); + set_has_status(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(58)) goto parse_error; + break; + } + + // repeated .bgs.protocol.ErrorInfo error = 7; + case 7: { + if (tag == 58) { + parse_error: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_error())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(58)) goto parse_error; + if (input->ExpectTag(64)) goto parse_timeout; + break; + } + + // optional uint64 timeout = 8; + case 8: { + if (tag == 64) { + parse_timeout: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &timeout_))); + set_has_timeout(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(72)) goto parse_is_response; + break; + } + + // optional bool is_response = 9; + case 9: { + if (tag == 72) { + parse_is_response: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_response_))); + set_has_is_response(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(82)) goto parse_forward_targets; + break; + } + + // repeated .bgs.protocol.ProcessId forward_targets = 10; + case 10: { + if (tag == 82) { + parse_forward_targets: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_forward_targets())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(82)) goto parse_forward_targets; + if (input->ExpectTag(93)) goto parse_service_hash; + break; + } + + // optional fixed32 service_hash = 11; + case 11: { + if (tag == 93) { + parse_service_hash: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &service_hash_))); + set_has_service_hash(); + } 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:bgs.protocol.Header) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.Header) + return false; +#undef DO_ +} + +void Header::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.Header) + // required uint32 service_id = 1; + if (has_service_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->service_id(), output); + } + + // optional uint32 method_id = 2; + if (has_method_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->method_id(), output); + } + + // required uint32 token = 3; + if (has_token()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->token(), output); + } + + // optional uint64 object_id = 4 [default = 0]; + if (has_object_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->object_id(), output); + } + + // optional uint32 size = 5 [default = 0]; + if (has_size()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->size(), output); + } + + // optional uint32 status = 6 [default = 0]; + if (has_status()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->status(), output); + } + + // repeated .bgs.protocol.ErrorInfo error = 7; + for (int i = 0; i < this->error_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 7, this->error(i), output); + } + + // optional uint64 timeout = 8; + if (has_timeout()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(8, this->timeout(), output); + } + + // optional bool is_response = 9; + if (has_is_response()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(9, this->is_response(), output); + } + + // repeated .bgs.protocol.ProcessId forward_targets = 10; + for (int i = 0; i < this->forward_targets_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 10, this->forward_targets(i), output); + } + + // optional fixed32 service_hash = 11; + if (has_service_hash()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(11, this->service_hash(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.Header) +} + +::google::protobuf::uint8* Header::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.Header) + // required uint32 service_id = 1; + if (has_service_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->service_id(), target); + } + + // optional uint32 method_id = 2; + if (has_method_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->method_id(), target); + } + + // required uint32 token = 3; + if (has_token()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->token(), target); + } + + // optional uint64 object_id = 4 [default = 0]; + if (has_object_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->object_id(), target); + } + + // optional uint32 size = 5 [default = 0]; + if (has_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->size(), target); + } + + // optional uint32 status = 6 [default = 0]; + if (has_status()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->status(), target); + } + + // repeated .bgs.protocol.ErrorInfo error = 7; + for (int i = 0; i < this->error_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 7, this->error(i), target); + } + + // optional uint64 timeout = 8; + if (has_timeout()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(8, this->timeout(), target); + } + + // optional bool is_response = 9; + if (has_is_response()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(9, this->is_response(), target); + } + + // repeated .bgs.protocol.ProcessId forward_targets = 10; + for (int i = 0; i < this->forward_targets_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 10, this->forward_targets(i), target); + } + + // optional fixed32 service_hash = 11; + if (has_service_hash()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(11, this->service_hash(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.Header) + return target; +} + +int Header::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required uint32 service_id = 1; + if (has_service_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->service_id()); + } + + // optional uint32 method_id = 2; + if (has_method_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->method_id()); + } + + // required uint32 token = 3; + if (has_token()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->token()); + } + + // optional uint64 object_id = 4 [default = 0]; + if (has_object_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->object_id()); + } + + // optional uint32 size = 5 [default = 0]; + if (has_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->size()); + } + + // optional uint32 status = 6 [default = 0]; + if (has_status()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->status()); + } + + // optional uint64 timeout = 8; + if (has_timeout()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->timeout()); + } + + } + if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + // optional bool is_response = 9; + if (has_is_response()) { + total_size += 1 + 1; + } + + // optional fixed32 service_hash = 11; + if (has_service_hash()) { + total_size += 1 + 4; + } + + } + // repeated .bgs.protocol.ErrorInfo error = 7; + total_size += 1 * this->error_size(); + for (int i = 0; i < this->error_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->error(i)); + } + + // repeated .bgs.protocol.ProcessId forward_targets = 10; + total_size += 1 * this->forward_targets_size(); + for (int i = 0; i < this->forward_targets_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->forward_targets(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 Header::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Header* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Header::MergeFrom(const Header& from) { + GOOGLE_CHECK_NE(&from, this); + error_.MergeFrom(from.error_); + forward_targets_.MergeFrom(from.forward_targets_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_service_id()) { + set_service_id(from.service_id()); + } + if (from.has_method_id()) { + set_method_id(from.method_id()); + } + if (from.has_token()) { + set_token(from.token()); + } + if (from.has_object_id()) { + set_object_id(from.object_id()); + } + if (from.has_size()) { + set_size(from.size()); + } + if (from.has_status()) { + set_status(from.status()); + } + if (from.has_timeout()) { + set_timeout(from.timeout()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from.has_is_response()) { + set_is_response(from.is_response()); + } + if (from.has_service_hash()) { + set_service_hash(from.service_hash()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Header::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Header::CopyFrom(const Header& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Header::IsInitialized() const { + if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false; + + if (!::google::protobuf::internal::AllAreInitialized(this->error())) return false; + if (!::google::protobuf::internal::AllAreInitialized(this->forward_targets())) return false; + return true; +} + +void Header::Swap(Header* other) { + if (other != this) { + std::swap(service_id_, other->service_id_); + std::swap(method_id_, other->method_id_); + std::swap(token_, other->token_); + std::swap(object_id_, other->object_id_); + std::swap(size_, other->size_); + std::swap(status_, other->status_); + error_.Swap(&other->error_); + std::swap(timeout_, other->timeout_); + std::swap(is_response_, other->is_response_); + forward_targets_.Swap(&other->forward_targets_); + std::swap(service_hash_, other->service_hash_); + 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 Header::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Header_descriptor_; + metadata.reflection = Header_reflection_; + return metadata; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/rpc_types.pb.h b/src/server/proto/Client/rpc_types.pb.h new file mode 100644 index 00000000000..242947a32d1 --- /dev/null +++ b/src/server/proto/Client/rpc_types.pb.h @@ -0,0 +1,1410 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: rpc_types.proto + +#ifndef PROTOBUF_rpc_5ftypes_2eproto__INCLUDED +#define PROTOBUF_rpc_5ftypes_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include "global_extensions/method_options.pb.h" // IWYU pragma: export +#include "global_extensions/service_options.pb.h" // IWYU pragma: export +#include "global_extensions/field_options.pb.h" // IWYU pragma: export +#include "Define.h" // for TRINITY_SHARED_API +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_rpc_5ftypes_2eproto(); +void protobuf_AssignDesc_rpc_5ftypes_2eproto(); +void protobuf_ShutdownFile_rpc_5ftypes_2eproto(); + +class NO_RESPONSE; +class Address; +class ProcessId; +class ObjectAddress; +class NoData; +class ErrorInfo; +class Header; + +// =================================================================== + +class TC_SHARED_API NO_RESPONSE : public ::google::protobuf::Message { + public: + NO_RESPONSE(); + virtual ~NO_RESPONSE(); + + NO_RESPONSE(const NO_RESPONSE& from); + + inline NO_RESPONSE& operator=(const NO_RESPONSE& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const NO_RESPONSE& default_instance(); + + void Swap(NO_RESPONSE* other); + + // implements Message ---------------------------------------------- + + NO_RESPONSE* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const NO_RESPONSE& from); + void MergeFrom(const NO_RESPONSE& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:bgs.protocol.NO_RESPONSE) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + friend void TC_SHARED_API protobuf_AddDesc_rpc_5ftypes_2eproto(); + friend void protobuf_AssignDesc_rpc_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_rpc_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static NO_RESPONSE* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API Address : public ::google::protobuf::Message { + public: + Address(); + virtual ~Address(); + + Address(const Address& from); + + inline Address& operator=(const Address& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Address& default_instance(); + + void Swap(Address* other); + + // implements Message ---------------------------------------------- + + Address* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Address& from); + void MergeFrom(const Address& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string address = 1; + inline bool has_address() const; + inline void clear_address(); + static const int kAddressFieldNumber = 1; + inline const ::std::string& address() const; + inline void set_address(const ::std::string& value); + inline void set_address(const char* value); + inline void set_address(const char* value, size_t size); + inline ::std::string* mutable_address(); + inline ::std::string* release_address(); + inline void set_allocated_address(::std::string* address); + + // optional uint32 port = 2; + inline bool has_port() const; + inline void clear_port(); + static const int kPortFieldNumber = 2; + inline ::google::protobuf::uint32 port() const; + inline void set_port(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.Address) + private: + inline void set_has_address(); + inline void clear_has_address(); + inline void set_has_port(); + inline void clear_has_port(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::std::string* address_; + ::google::protobuf::uint32 port_; + friend void TC_SHARED_API protobuf_AddDesc_rpc_5ftypes_2eproto(); + friend void protobuf_AssignDesc_rpc_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_rpc_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static Address* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ProcessId : public ::google::protobuf::Message { + public: + ProcessId(); + virtual ~ProcessId(); + + ProcessId(const ProcessId& from); + + inline ProcessId& operator=(const ProcessId& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ProcessId& default_instance(); + + void Swap(ProcessId* other); + + // implements Message ---------------------------------------------- + + ProcessId* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ProcessId& from); + void MergeFrom(const ProcessId& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required uint32 label = 1; + inline bool has_label() const; + inline void clear_label(); + static const int kLabelFieldNumber = 1; + inline ::google::protobuf::uint32 label() const; + inline void set_label(::google::protobuf::uint32 value); + + // required uint32 epoch = 2; + inline bool has_epoch() const; + inline void clear_epoch(); + static const int kEpochFieldNumber = 2; + inline ::google::protobuf::uint32 epoch() const; + inline void set_epoch(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.ProcessId) + private: + inline void set_has_label(); + inline void clear_has_label(); + inline void set_has_epoch(); + inline void clear_has_epoch(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 label_; + ::google::protobuf::uint32 epoch_; + friend void TC_SHARED_API protobuf_AddDesc_rpc_5ftypes_2eproto(); + friend void protobuf_AssignDesc_rpc_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_rpc_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static ProcessId* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ObjectAddress : public ::google::protobuf::Message { + public: + ObjectAddress(); + virtual ~ObjectAddress(); + + ObjectAddress(const ObjectAddress& from); + + inline ObjectAddress& operator=(const ObjectAddress& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ObjectAddress& default_instance(); + + void Swap(ObjectAddress* other); + + // implements Message ---------------------------------------------- + + ObjectAddress* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ObjectAddress& from); + void MergeFrom(const ObjectAddress& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.ProcessId host = 1; + inline bool has_host() const; + inline void clear_host(); + static const int kHostFieldNumber = 1; + inline const ::bgs::protocol::ProcessId& host() const; + inline ::bgs::protocol::ProcessId* mutable_host(); + inline ::bgs::protocol::ProcessId* release_host(); + inline void set_allocated_host(::bgs::protocol::ProcessId* host); + + // optional uint64 object_id = 2 [default = 0]; + inline bool has_object_id() const; + inline void clear_object_id(); + static const int kObjectIdFieldNumber = 2; + inline ::google::protobuf::uint64 object_id() const; + inline void set_object_id(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.ObjectAddress) + private: + inline void set_has_host(); + inline void clear_has_host(); + inline void set_has_object_id(); + inline void clear_has_object_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::ProcessId* host_; + ::google::protobuf::uint64 object_id_; + friend void TC_SHARED_API protobuf_AddDesc_rpc_5ftypes_2eproto(); + friend void protobuf_AssignDesc_rpc_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_rpc_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static ObjectAddress* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API NoData : public ::google::protobuf::Message { + public: + NoData(); + virtual ~NoData(); + + NoData(const NoData& from); + + inline NoData& operator=(const NoData& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const NoData& default_instance(); + + void Swap(NoData* other); + + // implements Message ---------------------------------------------- + + NoData* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const NoData& from); + void MergeFrom(const NoData& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:bgs.protocol.NoData) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + friend void TC_SHARED_API protobuf_AddDesc_rpc_5ftypes_2eproto(); + friend void protobuf_AssignDesc_rpc_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_rpc_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static NoData* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ErrorInfo : public ::google::protobuf::Message { + public: + ErrorInfo(); + virtual ~ErrorInfo(); + + ErrorInfo(const ErrorInfo& from); + + inline ErrorInfo& operator=(const ErrorInfo& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ErrorInfo& default_instance(); + + void Swap(ErrorInfo* other); + + // implements Message ---------------------------------------------- + + ErrorInfo* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ErrorInfo& from); + void MergeFrom(const ErrorInfo& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.ObjectAddress object_address = 1; + inline bool has_object_address() const; + inline void clear_object_address(); + static const int kObjectAddressFieldNumber = 1; + inline const ::bgs::protocol::ObjectAddress& object_address() const; + inline ::bgs::protocol::ObjectAddress* mutable_object_address(); + inline ::bgs::protocol::ObjectAddress* release_object_address(); + inline void set_allocated_object_address(::bgs::protocol::ObjectAddress* object_address); + + // required uint32 status = 2; + inline bool has_status() const; + inline void clear_status(); + static const int kStatusFieldNumber = 2; + inline ::google::protobuf::uint32 status() const; + inline void set_status(::google::protobuf::uint32 value); + + // required uint32 service_hash = 3; + inline bool has_service_hash() const; + inline void clear_service_hash(); + static const int kServiceHashFieldNumber = 3; + inline ::google::protobuf::uint32 service_hash() const; + inline void set_service_hash(::google::protobuf::uint32 value); + + // required uint32 method_id = 4; + inline bool has_method_id() const; + inline void clear_method_id(); + static const int kMethodIdFieldNumber = 4; + inline ::google::protobuf::uint32 method_id() const; + inline void set_method_id(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.ErrorInfo) + private: + inline void set_has_object_address(); + inline void clear_has_object_address(); + inline void set_has_status(); + inline void clear_has_status(); + inline void set_has_service_hash(); + inline void clear_has_service_hash(); + inline void set_has_method_id(); + inline void clear_has_method_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::ObjectAddress* object_address_; + ::google::protobuf::uint32 status_; + ::google::protobuf::uint32 service_hash_; + ::google::protobuf::uint32 method_id_; + friend void TC_SHARED_API protobuf_AddDesc_rpc_5ftypes_2eproto(); + friend void protobuf_AssignDesc_rpc_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_rpc_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static ErrorInfo* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API Header : public ::google::protobuf::Message { + public: + Header(); + virtual ~Header(); + + Header(const Header& from); + + inline Header& operator=(const Header& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Header& default_instance(); + + void Swap(Header* other); + + // implements Message ---------------------------------------------- + + Header* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Header& from); + void MergeFrom(const Header& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required uint32 service_id = 1; + inline bool has_service_id() const; + inline void clear_service_id(); + static const int kServiceIdFieldNumber = 1; + inline ::google::protobuf::uint32 service_id() const; + inline void set_service_id(::google::protobuf::uint32 value); + + // optional uint32 method_id = 2; + inline bool has_method_id() const; + inline void clear_method_id(); + static const int kMethodIdFieldNumber = 2; + inline ::google::protobuf::uint32 method_id() const; + inline void set_method_id(::google::protobuf::uint32 value); + + // required uint32 token = 3; + inline bool has_token() const; + inline void clear_token(); + static const int kTokenFieldNumber = 3; + inline ::google::protobuf::uint32 token() const; + inline void set_token(::google::protobuf::uint32 value); + + // optional uint64 object_id = 4 [default = 0]; + inline bool has_object_id() const; + inline void clear_object_id(); + static const int kObjectIdFieldNumber = 4; + inline ::google::protobuf::uint64 object_id() const; + inline void set_object_id(::google::protobuf::uint64 value); + + // optional uint32 size = 5 [default = 0]; + inline bool has_size() const; + inline void clear_size(); + static const int kSizeFieldNumber = 5; + inline ::google::protobuf::uint32 size() const; + inline void set_size(::google::protobuf::uint32 value); + + // optional uint32 status = 6 [default = 0]; + inline bool has_status() const; + inline void clear_status(); + static const int kStatusFieldNumber = 6; + inline ::google::protobuf::uint32 status() const; + inline void set_status(::google::protobuf::uint32 value); + + // repeated .bgs.protocol.ErrorInfo error = 7; + inline int error_size() const; + inline void clear_error(); + static const int kErrorFieldNumber = 7; + inline const ::bgs::protocol::ErrorInfo& error(int index) const; + inline ::bgs::protocol::ErrorInfo* mutable_error(int index); + inline ::bgs::protocol::ErrorInfo* add_error(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ErrorInfo >& + error() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ErrorInfo >* + mutable_error(); + + // optional uint64 timeout = 8; + inline bool has_timeout() const; + inline void clear_timeout(); + static const int kTimeoutFieldNumber = 8; + inline ::google::protobuf::uint64 timeout() const; + inline void set_timeout(::google::protobuf::uint64 value); + + // optional bool is_response = 9; + inline bool has_is_response() const; + inline void clear_is_response(); + static const int kIsResponseFieldNumber = 9; + inline bool is_response() const; + inline void set_is_response(bool value); + + // repeated .bgs.protocol.ProcessId forward_targets = 10; + inline int forward_targets_size() const; + inline void clear_forward_targets(); + static const int kForwardTargetsFieldNumber = 10; + inline const ::bgs::protocol::ProcessId& forward_targets(int index) const; + inline ::bgs::protocol::ProcessId* mutable_forward_targets(int index); + inline ::bgs::protocol::ProcessId* add_forward_targets(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ProcessId >& + forward_targets() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ProcessId >* + mutable_forward_targets(); + + // optional fixed32 service_hash = 11; + inline bool has_service_hash() const; + inline void clear_service_hash(); + static const int kServiceHashFieldNumber = 11; + inline ::google::protobuf::uint32 service_hash() const; + inline void set_service_hash(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.Header) + private: + inline void set_has_service_id(); + inline void clear_has_service_id(); + inline void set_has_method_id(); + inline void clear_has_method_id(); + inline void set_has_token(); + inline void clear_has_token(); + inline void set_has_object_id(); + inline void clear_has_object_id(); + inline void set_has_size(); + inline void clear_has_size(); + inline void set_has_status(); + inline void clear_has_status(); + inline void set_has_timeout(); + inline void clear_has_timeout(); + inline void set_has_is_response(); + inline void clear_has_is_response(); + inline void set_has_service_hash(); + inline void clear_has_service_hash(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 service_id_; + ::google::protobuf::uint32 method_id_; + ::google::protobuf::uint64 object_id_; + ::google::protobuf::uint32 token_; + ::google::protobuf::uint32 size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ErrorInfo > error_; + ::google::protobuf::uint32 status_; + bool is_response_; + ::google::protobuf::uint64 timeout_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ProcessId > forward_targets_; + ::google::protobuf::uint32 service_hash_; + friend void TC_SHARED_API protobuf_AddDesc_rpc_5ftypes_2eproto(); + friend void protobuf_AssignDesc_rpc_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_rpc_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static Header* default_instance_; +}; +// =================================================================== + + +// =================================================================== + + +// =================================================================== + +// NO_RESPONSE + +// ------------------------------------------------------------------- + +// Address + +// required string address = 1; +inline bool Address::has_address() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Address::set_has_address() { + _has_bits_[0] |= 0x00000001u; +} +inline void Address::clear_has_address() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Address::clear_address() { + if (address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + address_->clear(); + } + clear_has_address(); +} +inline const ::std::string& Address::address() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Address.address) + return *address_; +} +inline void Address::set_address(const ::std::string& value) { + set_has_address(); + if (address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + address_ = new ::std::string; + } + address_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.Address.address) +} +inline void Address::set_address(const char* value) { + set_has_address(); + if (address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + address_ = new ::std::string; + } + address_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.Address.address) +} +inline void Address::set_address(const char* value, size_t size) { + set_has_address(); + if (address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + address_ = new ::std::string; + } + address_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.Address.address) +} +inline ::std::string* Address::mutable_address() { + set_has_address(); + if (address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + address_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.Address.address) + return address_; +} +inline ::std::string* Address::release_address() { + clear_has_address(); + if (address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = address_; + address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void Address::set_allocated_address(::std::string* address) { + if (address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete address_; + } + if (address) { + set_has_address(); + address_ = address; + } else { + clear_has_address(); + address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Address.address) +} + +// optional uint32 port = 2; +inline bool Address::has_port() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Address::set_has_port() { + _has_bits_[0] |= 0x00000002u; +} +inline void Address::clear_has_port() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Address::clear_port() { + port_ = 0u; + clear_has_port(); +} +inline ::google::protobuf::uint32 Address::port() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Address.port) + return port_; +} +inline void Address::set_port(::google::protobuf::uint32 value) { + set_has_port(); + port_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.Address.port) +} + +// ------------------------------------------------------------------- + +// ProcessId + +// required uint32 label = 1; +inline bool ProcessId::has_label() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ProcessId::set_has_label() { + _has_bits_[0] |= 0x00000001u; +} +inline void ProcessId::clear_has_label() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ProcessId::clear_label() { + label_ = 0u; + clear_has_label(); +} +inline ::google::protobuf::uint32 ProcessId::label() const { + // @@protoc_insertion_point(field_get:bgs.protocol.ProcessId.label) + return label_; +} +inline void ProcessId::set_label(::google::protobuf::uint32 value) { + set_has_label(); + label_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.ProcessId.label) +} + +// required uint32 epoch = 2; +inline bool ProcessId::has_epoch() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ProcessId::set_has_epoch() { + _has_bits_[0] |= 0x00000002u; +} +inline void ProcessId::clear_has_epoch() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ProcessId::clear_epoch() { + epoch_ = 0u; + clear_has_epoch(); +} +inline ::google::protobuf::uint32 ProcessId::epoch() const { + // @@protoc_insertion_point(field_get:bgs.protocol.ProcessId.epoch) + return epoch_; +} +inline void ProcessId::set_epoch(::google::protobuf::uint32 value) { + set_has_epoch(); + epoch_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.ProcessId.epoch) +} + +// ------------------------------------------------------------------- + +// ObjectAddress + +// required .bgs.protocol.ProcessId host = 1; +inline bool ObjectAddress::has_host() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ObjectAddress::set_has_host() { + _has_bits_[0] |= 0x00000001u; +} +inline void ObjectAddress::clear_has_host() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ObjectAddress::clear_host() { + if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear(); + clear_has_host(); +} +inline const ::bgs::protocol::ProcessId& ObjectAddress::host() const { + // @@protoc_insertion_point(field_get:bgs.protocol.ObjectAddress.host) + return host_ != NULL ? *host_ : *default_instance_->host_; +} +inline ::bgs::protocol::ProcessId* ObjectAddress::mutable_host() { + set_has_host(); + if (host_ == NULL) host_ = new ::bgs::protocol::ProcessId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.ObjectAddress.host) + return host_; +} +inline ::bgs::protocol::ProcessId* ObjectAddress::release_host() { + clear_has_host(); + ::bgs::protocol::ProcessId* temp = host_; + host_ = NULL; + return temp; +} +inline void ObjectAddress::set_allocated_host(::bgs::protocol::ProcessId* host) { + delete host_; + host_ = host; + if (host) { + set_has_host(); + } else { + clear_has_host(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.ObjectAddress.host) +} + +// optional uint64 object_id = 2 [default = 0]; +inline bool ObjectAddress::has_object_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ObjectAddress::set_has_object_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void ObjectAddress::clear_has_object_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ObjectAddress::clear_object_id() { + object_id_ = GOOGLE_ULONGLONG(0); + clear_has_object_id(); +} +inline ::google::protobuf::uint64 ObjectAddress::object_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.ObjectAddress.object_id) + return object_id_; +} +inline void ObjectAddress::set_object_id(::google::protobuf::uint64 value) { + set_has_object_id(); + object_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.ObjectAddress.object_id) +} + +// ------------------------------------------------------------------- + +// NoData + +// ------------------------------------------------------------------- + +// ErrorInfo + +// required .bgs.protocol.ObjectAddress object_address = 1; +inline bool ErrorInfo::has_object_address() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ErrorInfo::set_has_object_address() { + _has_bits_[0] |= 0x00000001u; +} +inline void ErrorInfo::clear_has_object_address() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ErrorInfo::clear_object_address() { + if (object_address_ != NULL) object_address_->::bgs::protocol::ObjectAddress::Clear(); + clear_has_object_address(); +} +inline const ::bgs::protocol::ObjectAddress& ErrorInfo::object_address() const { + // @@protoc_insertion_point(field_get:bgs.protocol.ErrorInfo.object_address) + return object_address_ != NULL ? *object_address_ : *default_instance_->object_address_; +} +inline ::bgs::protocol::ObjectAddress* ErrorInfo::mutable_object_address() { + set_has_object_address(); + if (object_address_ == NULL) object_address_ = new ::bgs::protocol::ObjectAddress; + // @@protoc_insertion_point(field_mutable:bgs.protocol.ErrorInfo.object_address) + return object_address_; +} +inline ::bgs::protocol::ObjectAddress* ErrorInfo::release_object_address() { + clear_has_object_address(); + ::bgs::protocol::ObjectAddress* temp = object_address_; + object_address_ = NULL; + return temp; +} +inline void ErrorInfo::set_allocated_object_address(::bgs::protocol::ObjectAddress* object_address) { + delete object_address_; + object_address_ = object_address; + if (object_address) { + set_has_object_address(); + } else { + clear_has_object_address(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.ErrorInfo.object_address) +} + +// required uint32 status = 2; +inline bool ErrorInfo::has_status() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ErrorInfo::set_has_status() { + _has_bits_[0] |= 0x00000002u; +} +inline void ErrorInfo::clear_has_status() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ErrorInfo::clear_status() { + status_ = 0u; + clear_has_status(); +} +inline ::google::protobuf::uint32 ErrorInfo::status() const { + // @@protoc_insertion_point(field_get:bgs.protocol.ErrorInfo.status) + return status_; +} +inline void ErrorInfo::set_status(::google::protobuf::uint32 value) { + set_has_status(); + status_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.ErrorInfo.status) +} + +// required uint32 service_hash = 3; +inline bool ErrorInfo::has_service_hash() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ErrorInfo::set_has_service_hash() { + _has_bits_[0] |= 0x00000004u; +} +inline void ErrorInfo::clear_has_service_hash() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ErrorInfo::clear_service_hash() { + service_hash_ = 0u; + clear_has_service_hash(); +} +inline ::google::protobuf::uint32 ErrorInfo::service_hash() const { + // @@protoc_insertion_point(field_get:bgs.protocol.ErrorInfo.service_hash) + return service_hash_; +} +inline void ErrorInfo::set_service_hash(::google::protobuf::uint32 value) { + set_has_service_hash(); + service_hash_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.ErrorInfo.service_hash) +} + +// required uint32 method_id = 4; +inline bool ErrorInfo::has_method_id() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void ErrorInfo::set_has_method_id() { + _has_bits_[0] |= 0x00000008u; +} +inline void ErrorInfo::clear_has_method_id() { + _has_bits_[0] &= ~0x00000008u; +} +inline void ErrorInfo::clear_method_id() { + method_id_ = 0u; + clear_has_method_id(); +} +inline ::google::protobuf::uint32 ErrorInfo::method_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.ErrorInfo.method_id) + return method_id_; +} +inline void ErrorInfo::set_method_id(::google::protobuf::uint32 value) { + set_has_method_id(); + method_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.ErrorInfo.method_id) +} + +// ------------------------------------------------------------------- + +// Header + +// required uint32 service_id = 1; +inline bool Header::has_service_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Header::set_has_service_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void Header::clear_has_service_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Header::clear_service_id() { + service_id_ = 0u; + clear_has_service_id(); +} +inline ::google::protobuf::uint32 Header::service_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Header.service_id) + return service_id_; +} +inline void Header::set_service_id(::google::protobuf::uint32 value) { + set_has_service_id(); + service_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.Header.service_id) +} + +// optional uint32 method_id = 2; +inline bool Header::has_method_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Header::set_has_method_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void Header::clear_has_method_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Header::clear_method_id() { + method_id_ = 0u; + clear_has_method_id(); +} +inline ::google::protobuf::uint32 Header::method_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Header.method_id) + return method_id_; +} +inline void Header::set_method_id(::google::protobuf::uint32 value) { + set_has_method_id(); + method_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.Header.method_id) +} + +// required uint32 token = 3; +inline bool Header::has_token() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void Header::set_has_token() { + _has_bits_[0] |= 0x00000004u; +} +inline void Header::clear_has_token() { + _has_bits_[0] &= ~0x00000004u; +} +inline void Header::clear_token() { + token_ = 0u; + clear_has_token(); +} +inline ::google::protobuf::uint32 Header::token() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Header.token) + return token_; +} +inline void Header::set_token(::google::protobuf::uint32 value) { + set_has_token(); + token_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.Header.token) +} + +// optional uint64 object_id = 4 [default = 0]; +inline bool Header::has_object_id() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void Header::set_has_object_id() { + _has_bits_[0] |= 0x00000008u; +} +inline void Header::clear_has_object_id() { + _has_bits_[0] &= ~0x00000008u; +} +inline void Header::clear_object_id() { + object_id_ = GOOGLE_ULONGLONG(0); + clear_has_object_id(); +} +inline ::google::protobuf::uint64 Header::object_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Header.object_id) + return object_id_; +} +inline void Header::set_object_id(::google::protobuf::uint64 value) { + set_has_object_id(); + object_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.Header.object_id) +} + +// optional uint32 size = 5 [default = 0]; +inline bool Header::has_size() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void Header::set_has_size() { + _has_bits_[0] |= 0x00000010u; +} +inline void Header::clear_has_size() { + _has_bits_[0] &= ~0x00000010u; +} +inline void Header::clear_size() { + size_ = 0u; + clear_has_size(); +} +inline ::google::protobuf::uint32 Header::size() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Header.size) + return size_; +} +inline void Header::set_size(::google::protobuf::uint32 value) { + set_has_size(); + size_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.Header.size) +} + +// optional uint32 status = 6 [default = 0]; +inline bool Header::has_status() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void Header::set_has_status() { + _has_bits_[0] |= 0x00000020u; +} +inline void Header::clear_has_status() { + _has_bits_[0] &= ~0x00000020u; +} +inline void Header::clear_status() { + status_ = 0u; + clear_has_status(); +} +inline ::google::protobuf::uint32 Header::status() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Header.status) + return status_; +} +inline void Header::set_status(::google::protobuf::uint32 value) { + set_has_status(); + status_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.Header.status) +} + +// repeated .bgs.protocol.ErrorInfo error = 7; +inline int Header::error_size() const { + return error_.size(); +} +inline void Header::clear_error() { + error_.Clear(); +} +inline const ::bgs::protocol::ErrorInfo& Header::error(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.Header.error) + return error_.Get(index); +} +inline ::bgs::protocol::ErrorInfo* Header::mutable_error(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.Header.error) + return error_.Mutable(index); +} +inline ::bgs::protocol::ErrorInfo* Header::add_error() { + // @@protoc_insertion_point(field_add:bgs.protocol.Header.error) + return error_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ErrorInfo >& +Header::error() const { + // @@protoc_insertion_point(field_list:bgs.protocol.Header.error) + return error_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ErrorInfo >* +Header::mutable_error() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.Header.error) + return &error_; +} + +// optional uint64 timeout = 8; +inline bool Header::has_timeout() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void Header::set_has_timeout() { + _has_bits_[0] |= 0x00000080u; +} +inline void Header::clear_has_timeout() { + _has_bits_[0] &= ~0x00000080u; +} +inline void Header::clear_timeout() { + timeout_ = GOOGLE_ULONGLONG(0); + clear_has_timeout(); +} +inline ::google::protobuf::uint64 Header::timeout() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Header.timeout) + return timeout_; +} +inline void Header::set_timeout(::google::protobuf::uint64 value) { + set_has_timeout(); + timeout_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.Header.timeout) +} + +// optional bool is_response = 9; +inline bool Header::has_is_response() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void Header::set_has_is_response() { + _has_bits_[0] |= 0x00000100u; +} +inline void Header::clear_has_is_response() { + _has_bits_[0] &= ~0x00000100u; +} +inline void Header::clear_is_response() { + is_response_ = false; + clear_has_is_response(); +} +inline bool Header::is_response() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Header.is_response) + return is_response_; +} +inline void Header::set_is_response(bool value) { + set_has_is_response(); + is_response_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.Header.is_response) +} + +// repeated .bgs.protocol.ProcessId forward_targets = 10; +inline int Header::forward_targets_size() const { + return forward_targets_.size(); +} +inline void Header::clear_forward_targets() { + forward_targets_.Clear(); +} +inline const ::bgs::protocol::ProcessId& Header::forward_targets(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.Header.forward_targets) + return forward_targets_.Get(index); +} +inline ::bgs::protocol::ProcessId* Header::mutable_forward_targets(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.Header.forward_targets) + return forward_targets_.Mutable(index); +} +inline ::bgs::protocol::ProcessId* Header::add_forward_targets() { + // @@protoc_insertion_point(field_add:bgs.protocol.Header.forward_targets) + return forward_targets_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ProcessId >& +Header::forward_targets() const { + // @@protoc_insertion_point(field_list:bgs.protocol.Header.forward_targets) + return forward_targets_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ProcessId >* +Header::mutable_forward_targets() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.Header.forward_targets) + return &forward_targets_; +} + +// optional fixed32 service_hash = 11; +inline bool Header::has_service_hash() const { + return (_has_bits_[0] & 0x00000400u) != 0; +} +inline void Header::set_has_service_hash() { + _has_bits_[0] |= 0x00000400u; +} +inline void Header::clear_has_service_hash() { + _has_bits_[0] &= ~0x00000400u; +} +inline void Header::clear_service_hash() { + service_hash_ = 0u; + clear_has_service_hash(); +} +inline ::google::protobuf::uint32 Header::service_hash() const { + // @@protoc_insertion_point(field_get:bgs.protocol.Header.service_hash) + return service_hash_; +} +inline void Header::set_service_hash(::google::protobuf::uint32 value) { + set_has_service_hash(); + service_hash_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.Header.service_hash) +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_rpc_5ftypes_2eproto__INCLUDED diff --git a/src/server/proto/Client/user_manager_service.pb.cc b/src/server/proto/Client/user_manager_service.pb.cc new file mode 100644 index 00000000000..ba4d0c63190 --- /dev/null +++ b/src/server/proto/Client/user_manager_service.pb.cc @@ -0,0 +1,4520 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: user_manager_service.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "user_manager_service.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +#include "BattlenetRpcErrorCodes.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { +namespace user_manager { +namespace v1 { + +namespace { + +const ::google::protobuf::Descriptor* SubscribeRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SubscribeRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* SubscribeResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + SubscribeResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* UnsubscribeRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + UnsubscribeRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* AddRecentPlayersRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AddRecentPlayersRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* AddRecentPlayersResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AddRecentPlayersResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* ClearRecentPlayersRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ClearRecentPlayersRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* ClearRecentPlayersResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ClearRecentPlayersResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* BlockPlayerRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + BlockPlayerRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* UnblockPlayerRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + UnblockPlayerRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* BlockedPlayerAddedNotification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + BlockedPlayerAddedNotification_reflection_ = NULL; +const ::google::protobuf::Descriptor* BlockedPlayerRemovedNotification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + BlockedPlayerRemovedNotification_reflection_ = NULL; +const ::google::protobuf::Descriptor* RecentPlayersAddedNotification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + RecentPlayersAddedNotification_reflection_ = NULL; +const ::google::protobuf::Descriptor* RecentPlayersRemovedNotification_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + RecentPlayersRemovedNotification_reflection_ = NULL; +const ::google::protobuf::ServiceDescriptor* UserManagerService_descriptor_ = NULL; +const ::google::protobuf::ServiceDescriptor* UserManagerListener_descriptor_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto() { + protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "user_manager_service.proto"); + GOOGLE_CHECK(file != NULL); + SubscribeRequest_descriptor_ = file->message_type(0); + static const int SubscribeRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, object_id_), + }; + SubscribeRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + SubscribeRequest_descriptor_, + SubscribeRequest::default_instance_, + SubscribeRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(SubscribeRequest)); + SubscribeResponse_descriptor_ = file->message_type(1); + static const int SubscribeResponse_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, blocked_players_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, recent_players_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, role_), + }; + SubscribeResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + SubscribeResponse_descriptor_, + SubscribeResponse::default_instance_, + SubscribeResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(SubscribeResponse)); + UnsubscribeRequest_descriptor_ = file->message_type(2); + static const int UnsubscribeRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, object_id_), + }; + UnsubscribeRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + UnsubscribeRequest_descriptor_, + UnsubscribeRequest::default_instance_, + UnsubscribeRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(UnsubscribeRequest)); + AddRecentPlayersRequest_descriptor_ = file->message_type(3); + static const int AddRecentPlayersRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddRecentPlayersRequest, players_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddRecentPlayersRequest, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddRecentPlayersRequest, program_), + }; + AddRecentPlayersRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AddRecentPlayersRequest_descriptor_, + AddRecentPlayersRequest::default_instance_, + AddRecentPlayersRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddRecentPlayersRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddRecentPlayersRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AddRecentPlayersRequest)); + AddRecentPlayersResponse_descriptor_ = file->message_type(4); + static const int AddRecentPlayersResponse_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddRecentPlayersResponse, players_added_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddRecentPlayersResponse, players_removed_), + }; + AddRecentPlayersResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AddRecentPlayersResponse_descriptor_, + AddRecentPlayersResponse::default_instance_, + AddRecentPlayersResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddRecentPlayersResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddRecentPlayersResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AddRecentPlayersResponse)); + ClearRecentPlayersRequest_descriptor_ = file->message_type(5); + static const int ClearRecentPlayersRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClearRecentPlayersRequest, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClearRecentPlayersRequest, program_), + }; + ClearRecentPlayersRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ClearRecentPlayersRequest_descriptor_, + ClearRecentPlayersRequest::default_instance_, + ClearRecentPlayersRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClearRecentPlayersRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClearRecentPlayersRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ClearRecentPlayersRequest)); + ClearRecentPlayersResponse_descriptor_ = file->message_type(6); + static const int ClearRecentPlayersResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClearRecentPlayersResponse, players_removed_), + }; + ClearRecentPlayersResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ClearRecentPlayersResponse_descriptor_, + ClearRecentPlayersResponse::default_instance_, + ClearRecentPlayersResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClearRecentPlayersResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClearRecentPlayersResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ClearRecentPlayersResponse)); + BlockPlayerRequest_descriptor_ = file->message_type(7); + static const int BlockPlayerRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockPlayerRequest, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockPlayerRequest, target_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockPlayerRequest, role_), + }; + BlockPlayerRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + BlockPlayerRequest_descriptor_, + BlockPlayerRequest::default_instance_, + BlockPlayerRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockPlayerRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockPlayerRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(BlockPlayerRequest)); + UnblockPlayerRequest_descriptor_ = file->message_type(8); + static const int UnblockPlayerRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnblockPlayerRequest, agent_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnblockPlayerRequest, target_id_), + }; + UnblockPlayerRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + UnblockPlayerRequest_descriptor_, + UnblockPlayerRequest::default_instance_, + UnblockPlayerRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnblockPlayerRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnblockPlayerRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(UnblockPlayerRequest)); + BlockedPlayerAddedNotification_descriptor_ = file->message_type(9); + static const int BlockedPlayerAddedNotification_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayerAddedNotification, player_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayerAddedNotification, game_account_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayerAddedNotification, account_id_), + }; + BlockedPlayerAddedNotification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + BlockedPlayerAddedNotification_descriptor_, + BlockedPlayerAddedNotification::default_instance_, + BlockedPlayerAddedNotification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayerAddedNotification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayerAddedNotification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(BlockedPlayerAddedNotification)); + BlockedPlayerRemovedNotification_descriptor_ = file->message_type(10); + static const int BlockedPlayerRemovedNotification_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayerRemovedNotification, player_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayerRemovedNotification, game_account_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayerRemovedNotification, account_id_), + }; + BlockedPlayerRemovedNotification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + BlockedPlayerRemovedNotification_descriptor_, + BlockedPlayerRemovedNotification::default_instance_, + BlockedPlayerRemovedNotification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayerRemovedNotification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayerRemovedNotification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(BlockedPlayerRemovedNotification)); + RecentPlayersAddedNotification_descriptor_ = file->message_type(11); + static const int RecentPlayersAddedNotification_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayersAddedNotification, player_), + }; + RecentPlayersAddedNotification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + RecentPlayersAddedNotification_descriptor_, + RecentPlayersAddedNotification::default_instance_, + RecentPlayersAddedNotification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayersAddedNotification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayersAddedNotification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(RecentPlayersAddedNotification)); + RecentPlayersRemovedNotification_descriptor_ = file->message_type(12); + static const int RecentPlayersRemovedNotification_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayersRemovedNotification, player_), + }; + RecentPlayersRemovedNotification_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + RecentPlayersRemovedNotification_descriptor_, + RecentPlayersRemovedNotification::default_instance_, + RecentPlayersRemovedNotification_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayersRemovedNotification, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayersRemovedNotification, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(RecentPlayersRemovedNotification)); + UserManagerService_descriptor_ = file->service(0); + UserManagerListener_descriptor_ = file->service(1); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_user_5fmanager_5fservice_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SubscribeRequest_descriptor_, &SubscribeRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + SubscribeResponse_descriptor_, &SubscribeResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + UnsubscribeRequest_descriptor_, &UnsubscribeRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AddRecentPlayersRequest_descriptor_, &AddRecentPlayersRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AddRecentPlayersResponse_descriptor_, &AddRecentPlayersResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ClearRecentPlayersRequest_descriptor_, &ClearRecentPlayersRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ClearRecentPlayersResponse_descriptor_, &ClearRecentPlayersResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + BlockPlayerRequest_descriptor_, &BlockPlayerRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + UnblockPlayerRequest_descriptor_, &UnblockPlayerRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + BlockedPlayerAddedNotification_descriptor_, &BlockedPlayerAddedNotification::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + BlockedPlayerRemovedNotification_descriptor_, &BlockedPlayerRemovedNotification::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + RecentPlayersAddedNotification_descriptor_, &RecentPlayersAddedNotification::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + RecentPlayersRemovedNotification_descriptor_, &RecentPlayersRemovedNotification::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto() { + delete SubscribeRequest::default_instance_; + delete SubscribeRequest_reflection_; + delete SubscribeResponse::default_instance_; + delete SubscribeResponse_reflection_; + delete UnsubscribeRequest::default_instance_; + delete UnsubscribeRequest_reflection_; + delete AddRecentPlayersRequest::default_instance_; + delete AddRecentPlayersRequest_reflection_; + delete AddRecentPlayersResponse::default_instance_; + delete AddRecentPlayersResponse_reflection_; + delete ClearRecentPlayersRequest::default_instance_; + delete ClearRecentPlayersRequest_reflection_; + delete ClearRecentPlayersResponse::default_instance_; + delete ClearRecentPlayersResponse_reflection_; + delete BlockPlayerRequest::default_instance_; + delete BlockPlayerRequest_reflection_; + delete UnblockPlayerRequest::default_instance_; + delete UnblockPlayerRequest_reflection_; + delete BlockedPlayerAddedNotification::default_instance_; + delete BlockedPlayerAddedNotification_reflection_; + delete BlockedPlayerRemovedNotification::default_instance_; + delete BlockedPlayerRemovedNotification_reflection_; + delete RecentPlayersAddedNotification::default_instance_; + delete RecentPlayersAddedNotification_reflection_; + delete RecentPlayersRemovedNotification::default_instance_; + delete RecentPlayersRemovedNotification_reflection_; +} + +void protobuf_AddDesc_user_5fmanager_5fservice_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::bgs::protocol::user_manager::v1::protobuf_AddDesc_user_5fmanager_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_role_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\032user_manager_service.proto\022\034bgs.protoc" + "ol.user_manager.v1\032\030user_manager_types.p" + "roto\032\022entity_types.proto\032\020role_types.pro" + "to\032\017rpc_types.proto\"O\n\020SubscribeRequest\022" + "(\n\010agent_id\030\001 \001(\0132\026.bgs.protocol.EntityI" + "d\022\021\n\tobject_id\030\002 \002(\004\"\277\001\n\021SubscribeRespon" + "se\022D\n\017blocked_players\030\001 \003(\0132+.bgs.protoc" + "ol.user_manager.v1.BlockedPlayer\022B\n\016rece" + "nt_players\030\002 \003(\0132*.bgs.protocol.user_man" + "ager.v1.RecentPlayer\022 \n\004role\030\003 \003(\0132\022.bgs" + ".protocol.Role\"Q\n\022UnsubscribeRequest\022(\n\010" + "agent_id\030\001 \001(\0132\026.bgs.protocol.EntityId\022\021" + "\n\tobject_id\030\002 \001(\004\"\221\001\n\027AddRecentPlayersRe" + "quest\022;\n\007players\030\001 \003(\0132*.bgs.protocol.us" + "er_manager.v1.RecentPlayer\022(\n\010agent_id\030\002" + " \001(\0132\026.bgs.protocol.EntityId\022\017\n\007program\030" + "\003 \001(\r\"v\n\030AddRecentPlayersResponse\022A\n\rpla" + "yers_added\030\001 \003(\0132*.bgs.protocol.user_man" + "ager.v1.RecentPlayer\022\027\n\017players_removed\030" + "\003 \003(\007\"V\n\031ClearRecentPlayersRequest\022(\n\010ag" + "ent_id\030\001 \001(\0132\026.bgs.protocol.EntityId\022\017\n\007" + "program\030\002 \001(\r\"5\n\032ClearRecentPlayersRespo" + "nse\022\027\n\017players_removed\030\001 \003(\007\"w\n\022BlockPla" + "yerRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.proto" + "col.EntityId\022)\n\ttarget_id\030\002 \002(\0132\026.bgs.pr" + "otocol.EntityId\022\014\n\004role\030\003 \001(\r\"k\n\024Unblock" + "PlayerRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.pr" + "otocol.EntityId\022)\n\ttarget_id\030\002 \002(\0132\026.bgs" + ".protocol.EntityId\"\272\001\n\036BlockedPlayerAdde" + "dNotification\022;\n\006player\030\001 \002(\0132+.bgs.prot" + "ocol.user_manager.v1.BlockedPlayer\022/\n\017ga" + "me_account_id\030\002 \001(\0132\026.bgs.protocol.Entit" + "yId\022*\n\naccount_id\030\003 \001(\0132\026.bgs.protocol.E" + "ntityId\"\274\001\n BlockedPlayerRemovedNotifica" + "tion\022;\n\006player\030\001 \002(\0132+.bgs.protocol.user" + "_manager.v1.BlockedPlayer\022/\n\017game_accoun" + "t_id\030\002 \001(\0132\026.bgs.protocol.EntityId\022*\n\nac" + "count_id\030\003 \001(\0132\026.bgs.protocol.EntityId\"\\" + "\n\036RecentPlayersAddedNotification\022:\n\006play" + "er\030\001 \003(\0132*.bgs.protocol.user_manager.v1." + "RecentPlayer\"^\n RecentPlayersRemovedNoti" + "fication\022:\n\006player\030\001 \003(\0132*.bgs.protocol." + "user_manager.v1.RecentPlayer2\233\007\n\022UserMan" + "agerService\022r\n\tSubscribe\022..bgs.protocol." + "user_manager.v1.SubscribeRequest\032/.bgs.p" + "rotocol.user_manager.v1.SubscribeRespons" + "e\"\004\200\265\030\001\022\207\001\n\020AddRecentPlayers\0225.bgs.proto" + "col.user_manager.v1.AddRecentPlayersRequ" + "est\0326.bgs.protocol.user_manager.v1.AddRe" + "centPlayersResponse\"\004\200\265\030\n\022\215\001\n\022ClearRecen" + "tPlayers\0227.bgs.protocol.user_manager.v1." + "ClearRecentPlayersRequest\0328.bgs.protocol" + ".user_manager.v1.ClearRecentPlayersRespo" + "nse\"\004\200\265\030\013\022[\n\013BlockPlayer\0220.bgs.protocol." + "user_manager.v1.BlockPlayerRequest\032\024.bgs" + ".protocol.NoData\"\004\200\265\030\024\022_\n\rUnblockPlayer\022" + "2.bgs.protocol.user_manager.v1.UnblockPl" + "ayerRequest\032\024.bgs.protocol.NoData\"\004\200\265\030\025\022" + "e\n\025BlockPlayerForSession\0220.bgs.protocol." + "user_manager.v1.BlockPlayerRequest\032\024.bgs" + ".protocol.NoData\"\004\200\265\030(\022C\n\rLoadBlockList\022" + "\026.bgs.protocol.EntityId\032\024.bgs.protocol.N" + "oData\"\004\200\265\0302\022[\n\013Unsubscribe\0220.bgs.protoco" + "l.user_manager.v1.UnsubscribeRequest\032\024.b" + "gs.protocol.NoData\"\004\200\265\0303\0320\312>-bnet.protoc" + "ol.user_manager.UserManagerService2\252\004\n\023U" + "serManagerListener\022u\n\024OnBlockedPlayerAdd" + "ed\022<.bgs.protocol.user_manager.v1.Blocke" + "dPlayerAddedNotification\032\031.bgs.protocol." + "NO_RESPONSE\"\004\200\265\030\001\022y\n\026OnBlockedPlayerRemo" + "ved\022>.bgs.protocol.user_manager.v1.Block" + "edPlayerRemovedNotification\032\031.bgs.protoc" + "ol.NO_RESPONSE\"\004\200\265\030\002\022u\n\024OnRecentPlayersA" + "dded\022<.bgs.protocol.user_manager.v1.Rece" + "ntPlayersAddedNotification\032\031.bgs.protoco" + "l.NO_RESPONSE\"\004\200\265\030\013\022y\n\026OnRecentPlayersRe" + "moved\022>.bgs.protocol.user_manager.v1.Rec" + "entPlayersRemovedNotification\032\031.bgs.prot" + "ocol.NO_RESPONSE\"\004\200\265\030\014\032/\312>,bnet.protocol" + ".user_manager.UserManagerNotifyB\005H\001\200\001\000", 3198); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "user_manager_service.proto", &protobuf_RegisterTypes); + SubscribeRequest::default_instance_ = new SubscribeRequest(); + SubscribeResponse::default_instance_ = new SubscribeResponse(); + UnsubscribeRequest::default_instance_ = new UnsubscribeRequest(); + AddRecentPlayersRequest::default_instance_ = new AddRecentPlayersRequest(); + AddRecentPlayersResponse::default_instance_ = new AddRecentPlayersResponse(); + ClearRecentPlayersRequest::default_instance_ = new ClearRecentPlayersRequest(); + ClearRecentPlayersResponse::default_instance_ = new ClearRecentPlayersResponse(); + BlockPlayerRequest::default_instance_ = new BlockPlayerRequest(); + UnblockPlayerRequest::default_instance_ = new UnblockPlayerRequest(); + BlockedPlayerAddedNotification::default_instance_ = new BlockedPlayerAddedNotification(); + BlockedPlayerRemovedNotification::default_instance_ = new BlockedPlayerRemovedNotification(); + RecentPlayersAddedNotification::default_instance_ = new RecentPlayersAddedNotification(); + RecentPlayersRemovedNotification::default_instance_ = new RecentPlayersRemovedNotification(); + SubscribeRequest::default_instance_->InitAsDefaultInstance(); + SubscribeResponse::default_instance_->InitAsDefaultInstance(); + UnsubscribeRequest::default_instance_->InitAsDefaultInstance(); + AddRecentPlayersRequest::default_instance_->InitAsDefaultInstance(); + AddRecentPlayersResponse::default_instance_->InitAsDefaultInstance(); + ClearRecentPlayersRequest::default_instance_->InitAsDefaultInstance(); + ClearRecentPlayersResponse::default_instance_->InitAsDefaultInstance(); + BlockPlayerRequest::default_instance_->InitAsDefaultInstance(); + UnblockPlayerRequest::default_instance_->InitAsDefaultInstance(); + BlockedPlayerAddedNotification::default_instance_->InitAsDefaultInstance(); + BlockedPlayerRemovedNotification::default_instance_->InitAsDefaultInstance(); + RecentPlayersAddedNotification::default_instance_->InitAsDefaultInstance(); + RecentPlayersRemovedNotification::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_user_5fmanager_5fservice_2eproto { + StaticDescriptorInitializer_user_5fmanager_5fservice_2eproto() { + protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + } +} static_descriptor_initializer_user_5fmanager_5fservice_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int SubscribeRequest::kAgentIdFieldNumber; +const int SubscribeRequest::kObjectIdFieldNumber; +#endif // !_MSC_VER + +SubscribeRequest::SubscribeRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.SubscribeRequest) +} + +void SubscribeRequest::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +SubscribeRequest::SubscribeRequest(const SubscribeRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.SubscribeRequest) +} + +void SubscribeRequest::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + object_id_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +SubscribeRequest::~SubscribeRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.SubscribeRequest) + SharedDtor(); +} + +void SubscribeRequest::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + } +} + +void SubscribeRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SubscribeRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SubscribeRequest_descriptor_; +} + +const SubscribeRequest& SubscribeRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + return *default_instance_; +} + +SubscribeRequest* SubscribeRequest::default_instance_ = NULL; + +SubscribeRequest* SubscribeRequest::New() const { + return new SubscribeRequest; +} + +void SubscribeRequest::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + object_id_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool SubscribeRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.SubscribeRequest) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_object_id; + break; + } + + // required uint64 object_id = 2; + case 2: { + if (tag == 16) { + parse_object_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &object_id_))); + set_has_object_id(); + } 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:bgs.protocol.user_manager.v1.SubscribeRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.SubscribeRequest) + return false; +#undef DO_ +} + +void SubscribeRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.SubscribeRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // required uint64 object_id = 2; + if (has_object_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->object_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.SubscribeRequest) +} + +::google::protobuf::uint8* SubscribeRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.SubscribeRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // required uint64 object_id = 2; + if (has_object_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->object_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.SubscribeRequest) + return target; +} + +int SubscribeRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // required uint64 object_id = 2; + if (has_object_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->object_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void SubscribeRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const SubscribeRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void SubscribeRequest::MergeFrom(const SubscribeRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_object_id()) { + set_object_id(from.object_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void SubscribeRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SubscribeRequest::CopyFrom(const SubscribeRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SubscribeRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false; + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + return true; +} + +void SubscribeRequest::Swap(SubscribeRequest* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + std::swap(object_id_, other->object_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata SubscribeRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SubscribeRequest_descriptor_; + metadata.reflection = SubscribeRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int SubscribeResponse::kBlockedPlayersFieldNumber; +const int SubscribeResponse::kRecentPlayersFieldNumber; +const int SubscribeResponse::kRoleFieldNumber; +#endif // !_MSC_VER + +SubscribeResponse::SubscribeResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.SubscribeResponse) +} + +void SubscribeResponse::InitAsDefaultInstance() { +} + +SubscribeResponse::SubscribeResponse(const SubscribeResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.SubscribeResponse) +} + +void SubscribeResponse::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +SubscribeResponse::~SubscribeResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.SubscribeResponse) + SharedDtor(); +} + +void SubscribeResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void SubscribeResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* SubscribeResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return SubscribeResponse_descriptor_; +} + +const SubscribeResponse& SubscribeResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + return *default_instance_; +} + +SubscribeResponse* SubscribeResponse::default_instance_ = NULL; + +SubscribeResponse* SubscribeResponse::New() const { + return new SubscribeResponse; +} + +void SubscribeResponse::Clear() { + blocked_players_.Clear(); + recent_players_.Clear(); + role_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool SubscribeResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.SubscribeResponse) + 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 .bgs.protocol.user_manager.v1.BlockedPlayer blocked_players = 1; + case 1: { + if (tag == 10) { + parse_blocked_players: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_blocked_players())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_blocked_players; + if (input->ExpectTag(18)) goto parse_recent_players; + break; + } + + // repeated .bgs.protocol.user_manager.v1.RecentPlayer recent_players = 2; + case 2: { + if (tag == 18) { + parse_recent_players: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_recent_players())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_recent_players; + if (input->ExpectTag(26)) goto parse_role; + break; + } + + // repeated .bgs.protocol.Role role = 3; + case 3: { + if (tag == 26) { + parse_role: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_role())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_role; + 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:bgs.protocol.user_manager.v1.SubscribeResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.SubscribeResponse) + return false; +#undef DO_ +} + +void SubscribeResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.SubscribeResponse) + // repeated .bgs.protocol.user_manager.v1.BlockedPlayer blocked_players = 1; + for (int i = 0; i < this->blocked_players_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->blocked_players(i), output); + } + + // repeated .bgs.protocol.user_manager.v1.RecentPlayer recent_players = 2; + for (int i = 0; i < this->recent_players_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->recent_players(i), output); + } + + // repeated .bgs.protocol.Role role = 3; + for (int i = 0; i < this->role_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->role(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.SubscribeResponse) +} + +::google::protobuf::uint8* SubscribeResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.SubscribeResponse) + // repeated .bgs.protocol.user_manager.v1.BlockedPlayer blocked_players = 1; + for (int i = 0; i < this->blocked_players_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->blocked_players(i), target); + } + + // repeated .bgs.protocol.user_manager.v1.RecentPlayer recent_players = 2; + for (int i = 0; i < this->recent_players_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->recent_players(i), target); + } + + // repeated .bgs.protocol.Role role = 3; + for (int i = 0; i < this->role_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->role(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.SubscribeResponse) + return target; +} + +int SubscribeResponse::ByteSize() const { + int total_size = 0; + + // repeated .bgs.protocol.user_manager.v1.BlockedPlayer blocked_players = 1; + total_size += 1 * this->blocked_players_size(); + for (int i = 0; i < this->blocked_players_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->blocked_players(i)); + } + + // repeated .bgs.protocol.user_manager.v1.RecentPlayer recent_players = 2; + total_size += 1 * this->recent_players_size(); + for (int i = 0; i < this->recent_players_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->recent_players(i)); + } + + // repeated .bgs.protocol.Role role = 3; + total_size += 1 * this->role_size(); + for (int i = 0; i < this->role_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->role(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 SubscribeResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const SubscribeResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void SubscribeResponse::MergeFrom(const SubscribeResponse& from) { + GOOGLE_CHECK_NE(&from, this); + blocked_players_.MergeFrom(from.blocked_players_); + recent_players_.MergeFrom(from.recent_players_); + role_.MergeFrom(from.role_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void SubscribeResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SubscribeResponse::CopyFrom(const SubscribeResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SubscribeResponse::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->blocked_players())) return false; + if (!::google::protobuf::internal::AllAreInitialized(this->recent_players())) return false; + if (!::google::protobuf::internal::AllAreInitialized(this->role())) return false; + return true; +} + +void SubscribeResponse::Swap(SubscribeResponse* other) { + if (other != this) { + blocked_players_.Swap(&other->blocked_players_); + recent_players_.Swap(&other->recent_players_); + role_.Swap(&other->role_); + 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 SubscribeResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = SubscribeResponse_descriptor_; + metadata.reflection = SubscribeResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int UnsubscribeRequest::kAgentIdFieldNumber; +const int UnsubscribeRequest::kObjectIdFieldNumber; +#endif // !_MSC_VER + +UnsubscribeRequest::UnsubscribeRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.UnsubscribeRequest) +} + +void UnsubscribeRequest::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +UnsubscribeRequest::UnsubscribeRequest(const UnsubscribeRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.UnsubscribeRequest) +} + +void UnsubscribeRequest::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + object_id_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +UnsubscribeRequest::~UnsubscribeRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.UnsubscribeRequest) + SharedDtor(); +} + +void UnsubscribeRequest::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + } +} + +void UnsubscribeRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* UnsubscribeRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return UnsubscribeRequest_descriptor_; +} + +const UnsubscribeRequest& UnsubscribeRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + return *default_instance_; +} + +UnsubscribeRequest* UnsubscribeRequest::default_instance_ = NULL; + +UnsubscribeRequest* UnsubscribeRequest::New() const { + return new UnsubscribeRequest; +} + +void UnsubscribeRequest::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + object_id_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool UnsubscribeRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.UnsubscribeRequest) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_object_id; + break; + } + + // optional uint64 object_id = 2; + case 2: { + if (tag == 16) { + parse_object_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &object_id_))); + set_has_object_id(); + } 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:bgs.protocol.user_manager.v1.UnsubscribeRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.UnsubscribeRequest) + return false; +#undef DO_ +} + +void UnsubscribeRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.UnsubscribeRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // optional uint64 object_id = 2; + if (has_object_id()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->object_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.UnsubscribeRequest) +} + +::google::protobuf::uint8* UnsubscribeRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.UnsubscribeRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // optional uint64 object_id = 2; + if (has_object_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->object_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.UnsubscribeRequest) + return target; +} + +int UnsubscribeRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // optional uint64 object_id = 2; + if (has_object_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->object_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void UnsubscribeRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const UnsubscribeRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void UnsubscribeRequest::MergeFrom(const UnsubscribeRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_object_id()) { + set_object_id(from.object_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void UnsubscribeRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void UnsubscribeRequest::CopyFrom(const UnsubscribeRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool UnsubscribeRequest::IsInitialized() const { + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + return true; +} + +void UnsubscribeRequest::Swap(UnsubscribeRequest* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + std::swap(object_id_, other->object_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata UnsubscribeRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = UnsubscribeRequest_descriptor_; + metadata.reflection = UnsubscribeRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AddRecentPlayersRequest::kPlayersFieldNumber; +const int AddRecentPlayersRequest::kAgentIdFieldNumber; +const int AddRecentPlayersRequest::kProgramFieldNumber; +#endif // !_MSC_VER + +AddRecentPlayersRequest::AddRecentPlayersRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.AddRecentPlayersRequest) +} + +void AddRecentPlayersRequest::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +AddRecentPlayersRequest::AddRecentPlayersRequest(const AddRecentPlayersRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.AddRecentPlayersRequest) +} + +void AddRecentPlayersRequest::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + program_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AddRecentPlayersRequest::~AddRecentPlayersRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.AddRecentPlayersRequest) + SharedDtor(); +} + +void AddRecentPlayersRequest::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + } +} + +void AddRecentPlayersRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AddRecentPlayersRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AddRecentPlayersRequest_descriptor_; +} + +const AddRecentPlayersRequest& AddRecentPlayersRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + return *default_instance_; +} + +AddRecentPlayersRequest* AddRecentPlayersRequest::default_instance_ = NULL; + +AddRecentPlayersRequest* AddRecentPlayersRequest::New() const { + return new AddRecentPlayersRequest; +} + +void AddRecentPlayersRequest::Clear() { + if (_has_bits_[0 / 32] & 6) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + program_ = 0u; + } + players_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AddRecentPlayersRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.AddRecentPlayersRequest) + 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 .bgs.protocol.user_manager.v1.RecentPlayer players = 1; + case 1: { + if (tag == 10) { + parse_players: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_players())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_players; + if (input->ExpectTag(18)) goto parse_agent_id; + break; + } + + // optional .bgs.protocol.EntityId agent_id = 2; + case 2: { + if (tag == 18) { + parse_agent_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_program; + break; + } + + // optional uint32 program = 3; + case 3: { + if (tag == 24) { + parse_program: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &program_))); + set_has_program(); + } 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:bgs.protocol.user_manager.v1.AddRecentPlayersRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.AddRecentPlayersRequest) + return false; +#undef DO_ +} + +void AddRecentPlayersRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.AddRecentPlayersRequest) + // repeated .bgs.protocol.user_manager.v1.RecentPlayer players = 1; + for (int i = 0; i < this->players_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->players(i), output); + } + + // optional .bgs.protocol.EntityId agent_id = 2; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->agent_id(), output); + } + + // optional uint32 program = 3; + if (has_program()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->program(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.AddRecentPlayersRequest) +} + +::google::protobuf::uint8* AddRecentPlayersRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.AddRecentPlayersRequest) + // repeated .bgs.protocol.user_manager.v1.RecentPlayer players = 1; + for (int i = 0; i < this->players_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->players(i), target); + } + + // optional .bgs.protocol.EntityId agent_id = 2; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->agent_id(), target); + } + + // optional uint32 program = 3; + if (has_program()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->program(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.AddRecentPlayersRequest) + return target; +} + +int AddRecentPlayersRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 2; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // optional uint32 program = 3; + if (has_program()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->program()); + } + + } + // repeated .bgs.protocol.user_manager.v1.RecentPlayer players = 1; + total_size += 1 * this->players_size(); + for (int i = 0; i < this->players_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->players(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 AddRecentPlayersRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AddRecentPlayersRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AddRecentPlayersRequest::MergeFrom(const AddRecentPlayersRequest& from) { + GOOGLE_CHECK_NE(&from, this); + players_.MergeFrom(from.players_); + if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_program()) { + set_program(from.program()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AddRecentPlayersRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AddRecentPlayersRequest::CopyFrom(const AddRecentPlayersRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AddRecentPlayersRequest::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->players())) return false; + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + return true; +} + +void AddRecentPlayersRequest::Swap(AddRecentPlayersRequest* other) { + if (other != this) { + players_.Swap(&other->players_); + std::swap(agent_id_, other->agent_id_); + std::swap(program_, other->program_); + 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 AddRecentPlayersRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AddRecentPlayersRequest_descriptor_; + metadata.reflection = AddRecentPlayersRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AddRecentPlayersResponse::kPlayersAddedFieldNumber; +const int AddRecentPlayersResponse::kPlayersRemovedFieldNumber; +#endif // !_MSC_VER + +AddRecentPlayersResponse::AddRecentPlayersResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.AddRecentPlayersResponse) +} + +void AddRecentPlayersResponse::InitAsDefaultInstance() { +} + +AddRecentPlayersResponse::AddRecentPlayersResponse(const AddRecentPlayersResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.AddRecentPlayersResponse) +} + +void AddRecentPlayersResponse::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AddRecentPlayersResponse::~AddRecentPlayersResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.AddRecentPlayersResponse) + SharedDtor(); +} + +void AddRecentPlayersResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void AddRecentPlayersResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AddRecentPlayersResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AddRecentPlayersResponse_descriptor_; +} + +const AddRecentPlayersResponse& AddRecentPlayersResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + return *default_instance_; +} + +AddRecentPlayersResponse* AddRecentPlayersResponse::default_instance_ = NULL; + +AddRecentPlayersResponse* AddRecentPlayersResponse::New() const { + return new AddRecentPlayersResponse; +} + +void AddRecentPlayersResponse::Clear() { + players_added_.Clear(); + players_removed_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AddRecentPlayersResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.AddRecentPlayersResponse) + 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 .bgs.protocol.user_manager.v1.RecentPlayer players_added = 1; + case 1: { + if (tag == 10) { + parse_players_added: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_players_added())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_players_added; + if (input->ExpectTag(29)) goto parse_players_removed; + break; + } + + // repeated fixed32 players_removed = 3; + case 3: { + if (tag == 29) { + parse_players_removed: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + 1, 29, input, this->mutable_players_removed()))); + } else if (tag == 26) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, this->mutable_players_removed()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(29)) goto parse_players_removed; + 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:bgs.protocol.user_manager.v1.AddRecentPlayersResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.AddRecentPlayersResponse) + return false; +#undef DO_ +} + +void AddRecentPlayersResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.AddRecentPlayersResponse) + // repeated .bgs.protocol.user_manager.v1.RecentPlayer players_added = 1; + for (int i = 0; i < this->players_added_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->players_added(i), output); + } + + // repeated fixed32 players_removed = 3; + for (int i = 0; i < this->players_removed_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32( + 3, this->players_removed(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.AddRecentPlayersResponse) +} + +::google::protobuf::uint8* AddRecentPlayersResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.AddRecentPlayersResponse) + // repeated .bgs.protocol.user_manager.v1.RecentPlayer players_added = 1; + for (int i = 0; i < this->players_added_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->players_added(i), target); + } + + // repeated fixed32 players_removed = 3; + for (int i = 0; i < this->players_removed_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteFixed32ToArray(3, this->players_removed(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.AddRecentPlayersResponse) + return target; +} + +int AddRecentPlayersResponse::ByteSize() const { + int total_size = 0; + + // repeated .bgs.protocol.user_manager.v1.RecentPlayer players_added = 1; + total_size += 1 * this->players_added_size(); + for (int i = 0; i < this->players_added_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->players_added(i)); + } + + // repeated fixed32 players_removed = 3; + { + int data_size = 0; + data_size = 4 * this->players_removed_size(); + total_size += 1 * this->players_removed_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 AddRecentPlayersResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AddRecentPlayersResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AddRecentPlayersResponse::MergeFrom(const AddRecentPlayersResponse& from) { + GOOGLE_CHECK_NE(&from, this); + players_added_.MergeFrom(from.players_added_); + players_removed_.MergeFrom(from.players_removed_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AddRecentPlayersResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AddRecentPlayersResponse::CopyFrom(const AddRecentPlayersResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AddRecentPlayersResponse::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->players_added())) return false; + return true; +} + +void AddRecentPlayersResponse::Swap(AddRecentPlayersResponse* other) { + if (other != this) { + players_added_.Swap(&other->players_added_); + players_removed_.Swap(&other->players_removed_); + 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 AddRecentPlayersResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AddRecentPlayersResponse_descriptor_; + metadata.reflection = AddRecentPlayersResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ClearRecentPlayersRequest::kAgentIdFieldNumber; +const int ClearRecentPlayersRequest::kProgramFieldNumber; +#endif // !_MSC_VER + +ClearRecentPlayersRequest::ClearRecentPlayersRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest) +} + +void ClearRecentPlayersRequest::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +ClearRecentPlayersRequest::ClearRecentPlayersRequest(const ClearRecentPlayersRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest) +} + +void ClearRecentPlayersRequest::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + program_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ClearRecentPlayersRequest::~ClearRecentPlayersRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest) + SharedDtor(); +} + +void ClearRecentPlayersRequest::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + } +} + +void ClearRecentPlayersRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ClearRecentPlayersRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ClearRecentPlayersRequest_descriptor_; +} + +const ClearRecentPlayersRequest& ClearRecentPlayersRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + return *default_instance_; +} + +ClearRecentPlayersRequest* ClearRecentPlayersRequest::default_instance_ = NULL; + +ClearRecentPlayersRequest* ClearRecentPlayersRequest::New() const { + return new ClearRecentPlayersRequest; +} + +void ClearRecentPlayersRequest::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + program_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ClearRecentPlayersRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_program; + break; + } + + // optional uint32 program = 2; + case 2: { + if (tag == 16) { + parse_program: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &program_))); + set_has_program(); + } 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:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest) + return false; +#undef DO_ +} + +void ClearRecentPlayersRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // optional uint32 program = 2; + if (has_program()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->program(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest) +} + +::google::protobuf::uint8* ClearRecentPlayersRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // optional uint32 program = 2; + if (has_program()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->program(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest) + return target; +} + +int ClearRecentPlayersRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // optional uint32 program = 2; + if (has_program()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->program()); + } + + } + 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 ClearRecentPlayersRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ClearRecentPlayersRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ClearRecentPlayersRequest::MergeFrom(const ClearRecentPlayersRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_program()) { + set_program(from.program()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ClearRecentPlayersRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ClearRecentPlayersRequest::CopyFrom(const ClearRecentPlayersRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ClearRecentPlayersRequest::IsInitialized() const { + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + return true; +} + +void ClearRecentPlayersRequest::Swap(ClearRecentPlayersRequest* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + std::swap(program_, other->program_); + 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 ClearRecentPlayersRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ClearRecentPlayersRequest_descriptor_; + metadata.reflection = ClearRecentPlayersRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ClearRecentPlayersResponse::kPlayersRemovedFieldNumber; +#endif // !_MSC_VER + +ClearRecentPlayersResponse::ClearRecentPlayersResponse() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse) +} + +void ClearRecentPlayersResponse::InitAsDefaultInstance() { +} + +ClearRecentPlayersResponse::ClearRecentPlayersResponse(const ClearRecentPlayersResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse) +} + +void ClearRecentPlayersResponse::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ClearRecentPlayersResponse::~ClearRecentPlayersResponse() { + // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse) + SharedDtor(); +} + +void ClearRecentPlayersResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void ClearRecentPlayersResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ClearRecentPlayersResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ClearRecentPlayersResponse_descriptor_; +} + +const ClearRecentPlayersResponse& ClearRecentPlayersResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + return *default_instance_; +} + +ClearRecentPlayersResponse* ClearRecentPlayersResponse::default_instance_ = NULL; + +ClearRecentPlayersResponse* ClearRecentPlayersResponse::New() const { + return new ClearRecentPlayersResponse; +} + +void ClearRecentPlayersResponse::Clear() { + players_removed_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ClearRecentPlayersResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse) + 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 players_removed = 1; + case 1: { + if (tag == 13) { + parse_players_removed: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + 1, 13, input, this->mutable_players_removed()))); + } else if (tag == 10) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, this->mutable_players_removed()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(13)) goto parse_players_removed; + 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:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse) + return false; +#undef DO_ +} + +void ClearRecentPlayersResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse) + // repeated fixed32 players_removed = 1; + for (int i = 0; i < this->players_removed_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32( + 1, this->players_removed(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse) +} + +::google::protobuf::uint8* ClearRecentPlayersResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse) + // repeated fixed32 players_removed = 1; + for (int i = 0; i < this->players_removed_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteFixed32ToArray(1, this->players_removed(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse) + return target; +} + +int ClearRecentPlayersResponse::ByteSize() const { + int total_size = 0; + + // repeated fixed32 players_removed = 1; + { + int data_size = 0; + data_size = 4 * this->players_removed_size(); + total_size += 1 * this->players_removed_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 ClearRecentPlayersResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ClearRecentPlayersResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ClearRecentPlayersResponse::MergeFrom(const ClearRecentPlayersResponse& from) { + GOOGLE_CHECK_NE(&from, this); + players_removed_.MergeFrom(from.players_removed_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ClearRecentPlayersResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ClearRecentPlayersResponse::CopyFrom(const ClearRecentPlayersResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ClearRecentPlayersResponse::IsInitialized() const { + + return true; +} + +void ClearRecentPlayersResponse::Swap(ClearRecentPlayersResponse* other) { + if (other != this) { + players_removed_.Swap(&other->players_removed_); + 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 ClearRecentPlayersResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ClearRecentPlayersResponse_descriptor_; + metadata.reflection = ClearRecentPlayersResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int BlockPlayerRequest::kAgentIdFieldNumber; +const int BlockPlayerRequest::kTargetIdFieldNumber; +const int BlockPlayerRequest::kRoleFieldNumber; +#endif // !_MSC_VER + +BlockPlayerRequest::BlockPlayerRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.BlockPlayerRequest) +} + +void BlockPlayerRequest::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +BlockPlayerRequest::BlockPlayerRequest(const BlockPlayerRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.BlockPlayerRequest) +} + +void BlockPlayerRequest::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + target_id_ = NULL; + role_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +BlockPlayerRequest::~BlockPlayerRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.BlockPlayerRequest) + SharedDtor(); +} + +void BlockPlayerRequest::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + delete target_id_; + } +} + +void BlockPlayerRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* BlockPlayerRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return BlockPlayerRequest_descriptor_; +} + +const BlockPlayerRequest& BlockPlayerRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + return *default_instance_; +} + +BlockPlayerRequest* BlockPlayerRequest::default_instance_ = NULL; + +BlockPlayerRequest* BlockPlayerRequest::New() const { + return new BlockPlayerRequest; +} + +void BlockPlayerRequest::Clear() { + if (_has_bits_[0 / 32] & 7) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_target_id()) { + if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear(); + } + role_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool BlockPlayerRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.BlockPlayerRequest) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_target_id; + break; + } + + // required .bgs.protocol.EntityId target_id = 2; + case 2: { + if (tag == 18) { + parse_target_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_target_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(24)) goto parse_role; + break; + } + + // optional uint32 role = 3; + case 3: { + if (tag == 24) { + parse_role: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &role_))); + set_has_role(); + } 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:bgs.protocol.user_manager.v1.BlockPlayerRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.BlockPlayerRequest) + return false; +#undef DO_ +} + +void BlockPlayerRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.BlockPlayerRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // required .bgs.protocol.EntityId target_id = 2; + if (has_target_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->target_id(), output); + } + + // optional uint32 role = 3; + if (has_role()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->role(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.BlockPlayerRequest) +} + +::google::protobuf::uint8* BlockPlayerRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.BlockPlayerRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // required .bgs.protocol.EntityId target_id = 2; + if (has_target_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->target_id(), target); + } + + // optional uint32 role = 3; + if (has_role()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->role(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.BlockPlayerRequest) + return target; +} + +int BlockPlayerRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // required .bgs.protocol.EntityId target_id = 2; + if (has_target_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->target_id()); + } + + // optional uint32 role = 3; + if (has_role()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->role()); + } + + } + 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 BlockPlayerRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const BlockPlayerRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void BlockPlayerRequest::MergeFrom(const BlockPlayerRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_target_id()) { + mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id()); + } + if (from.has_role()) { + set_role(from.role()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void BlockPlayerRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void BlockPlayerRequest::CopyFrom(const BlockPlayerRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BlockPlayerRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false; + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + if (has_target_id()) { + if (!this->target_id().IsInitialized()) return false; + } + return true; +} + +void BlockPlayerRequest::Swap(BlockPlayerRequest* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + std::swap(target_id_, other->target_id_); + std::swap(role_, other->role_); + 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 BlockPlayerRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = BlockPlayerRequest_descriptor_; + metadata.reflection = BlockPlayerRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int UnblockPlayerRequest::kAgentIdFieldNumber; +const int UnblockPlayerRequest::kTargetIdFieldNumber; +#endif // !_MSC_VER + +UnblockPlayerRequest::UnblockPlayerRequest() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.UnblockPlayerRequest) +} + +void UnblockPlayerRequest::InitAsDefaultInstance() { + agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +UnblockPlayerRequest::UnblockPlayerRequest(const UnblockPlayerRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.UnblockPlayerRequest) +} + +void UnblockPlayerRequest::SharedCtor() { + _cached_size_ = 0; + agent_id_ = NULL; + target_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +UnblockPlayerRequest::~UnblockPlayerRequest() { + // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.UnblockPlayerRequest) + SharedDtor(); +} + +void UnblockPlayerRequest::SharedDtor() { + if (this != default_instance_) { + delete agent_id_; + delete target_id_; + } +} + +void UnblockPlayerRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* UnblockPlayerRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return UnblockPlayerRequest_descriptor_; +} + +const UnblockPlayerRequest& UnblockPlayerRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + return *default_instance_; +} + +UnblockPlayerRequest* UnblockPlayerRequest::default_instance_ = NULL; + +UnblockPlayerRequest* UnblockPlayerRequest::New() const { + return new UnblockPlayerRequest; +} + +void UnblockPlayerRequest::Clear() { + if (_has_bits_[0 / 32] & 3) { + if (has_agent_id()) { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_target_id()) { + if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool UnblockPlayerRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.UnblockPlayerRequest) + 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 .bgs.protocol.EntityId agent_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_agent_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_target_id; + break; + } + + // required .bgs.protocol.EntityId target_id = 2; + case 2: { + if (tag == 18) { + parse_target_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_target_id())); + } 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:bgs.protocol.user_manager.v1.UnblockPlayerRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.UnblockPlayerRequest) + return false; +#undef DO_ +} + +void UnblockPlayerRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.UnblockPlayerRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->agent_id(), output); + } + + // required .bgs.protocol.EntityId target_id = 2; + if (has_target_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->target_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.UnblockPlayerRequest) +} + +::google::protobuf::uint8* UnblockPlayerRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.UnblockPlayerRequest) + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->agent_id(), target); + } + + // required .bgs.protocol.EntityId target_id = 2; + if (has_target_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->target_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.UnblockPlayerRequest) + return target; +} + +int UnblockPlayerRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .bgs.protocol.EntityId agent_id = 1; + if (has_agent_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->agent_id()); + } + + // required .bgs.protocol.EntityId target_id = 2; + if (has_target_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->target_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void UnblockPlayerRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const UnblockPlayerRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void UnblockPlayerRequest::MergeFrom(const UnblockPlayerRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_agent_id()) { + mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id()); + } + if (from.has_target_id()) { + mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void UnblockPlayerRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void UnblockPlayerRequest::CopyFrom(const UnblockPlayerRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool UnblockPlayerRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false; + + if (has_agent_id()) { + if (!this->agent_id().IsInitialized()) return false; + } + if (has_target_id()) { + if (!this->target_id().IsInitialized()) return false; + } + return true; +} + +void UnblockPlayerRequest::Swap(UnblockPlayerRequest* other) { + if (other != this) { + std::swap(agent_id_, other->agent_id_); + std::swap(target_id_, other->target_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata UnblockPlayerRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = UnblockPlayerRequest_descriptor_; + metadata.reflection = UnblockPlayerRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int BlockedPlayerAddedNotification::kPlayerFieldNumber; +const int BlockedPlayerAddedNotification::kGameAccountIdFieldNumber; +const int BlockedPlayerAddedNotification::kAccountIdFieldNumber; +#endif // !_MSC_VER + +BlockedPlayerAddedNotification::BlockedPlayerAddedNotification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification) +} + +void BlockedPlayerAddedNotification::InitAsDefaultInstance() { + player_ = const_cast< ::bgs::protocol::user_manager::v1::BlockedPlayer*>(&::bgs::protocol::user_manager::v1::BlockedPlayer::default_instance()); + game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +BlockedPlayerAddedNotification::BlockedPlayerAddedNotification(const BlockedPlayerAddedNotification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification) +} + +void BlockedPlayerAddedNotification::SharedCtor() { + _cached_size_ = 0; + player_ = NULL; + game_account_id_ = NULL; + account_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +BlockedPlayerAddedNotification::~BlockedPlayerAddedNotification() { + // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification) + SharedDtor(); +} + +void BlockedPlayerAddedNotification::SharedDtor() { + if (this != default_instance_) { + delete player_; + delete game_account_id_; + delete account_id_; + } +} + +void BlockedPlayerAddedNotification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* BlockedPlayerAddedNotification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return BlockedPlayerAddedNotification_descriptor_; +} + +const BlockedPlayerAddedNotification& BlockedPlayerAddedNotification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + return *default_instance_; +} + +BlockedPlayerAddedNotification* BlockedPlayerAddedNotification::default_instance_ = NULL; + +BlockedPlayerAddedNotification* BlockedPlayerAddedNotification::New() const { + return new BlockedPlayerAddedNotification; +} + +void BlockedPlayerAddedNotification::Clear() { + if (_has_bits_[0 / 32] & 7) { + if (has_player()) { + if (player_ != NULL) player_->::bgs::protocol::user_manager::v1::BlockedPlayer::Clear(); + } + if (has_game_account_id()) { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_account_id()) { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool BlockedPlayerAddedNotification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification) + 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)) { + // required .bgs.protocol.user_manager.v1.BlockedPlayer player = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_player())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_game_account_id; + break; + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + case 2: { + if (tag == 18) { + parse_game_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_account_id; + break; + } + + // optional .bgs.protocol.EntityId account_id = 3; + case 3: { + if (tag == 26) { + parse_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account_id())); + } 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:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification) + return false; +#undef DO_ +} + +void BlockedPlayerAddedNotification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification) + // required .bgs.protocol.user_manager.v1.BlockedPlayer player = 1; + if (has_player()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->player(), output); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->game_account_id(), output); + } + + // optional .bgs.protocol.EntityId account_id = 3; + if (has_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->account_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification) +} + +::google::protobuf::uint8* BlockedPlayerAddedNotification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification) + // required .bgs.protocol.user_manager.v1.BlockedPlayer player = 1; + if (has_player()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->player(), target); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->game_account_id(), target); + } + + // optional .bgs.protocol.EntityId account_id = 3; + if (has_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->account_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification) + return target; +} + +int BlockedPlayerAddedNotification::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.user_manager.v1.BlockedPlayer player = 1; + if (has_player()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->player()); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account_id()); + } + + // optional .bgs.protocol.EntityId account_id = 3; + if (has_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void BlockedPlayerAddedNotification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const BlockedPlayerAddedNotification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void BlockedPlayerAddedNotification::MergeFrom(const BlockedPlayerAddedNotification& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_player()) { + mutable_player()->::bgs::protocol::user_manager::v1::BlockedPlayer::MergeFrom(from.player()); + } + if (from.has_game_account_id()) { + mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id()); + } + if (from.has_account_id()) { + mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void BlockedPlayerAddedNotification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void BlockedPlayerAddedNotification::CopyFrom(const BlockedPlayerAddedNotification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BlockedPlayerAddedNotification::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_player()) { + if (!this->player().IsInitialized()) return false; + } + if (has_game_account_id()) { + if (!this->game_account_id().IsInitialized()) return false; + } + if (has_account_id()) { + if (!this->account_id().IsInitialized()) return false; + } + return true; +} + +void BlockedPlayerAddedNotification::Swap(BlockedPlayerAddedNotification* other) { + if (other != this) { + std::swap(player_, other->player_); + std::swap(game_account_id_, other->game_account_id_); + std::swap(account_id_, other->account_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata BlockedPlayerAddedNotification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = BlockedPlayerAddedNotification_descriptor_; + metadata.reflection = BlockedPlayerAddedNotification_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int BlockedPlayerRemovedNotification::kPlayerFieldNumber; +const int BlockedPlayerRemovedNotification::kGameAccountIdFieldNumber; +const int BlockedPlayerRemovedNotification::kAccountIdFieldNumber; +#endif // !_MSC_VER + +BlockedPlayerRemovedNotification::BlockedPlayerRemovedNotification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification) +} + +void BlockedPlayerRemovedNotification::InitAsDefaultInstance() { + player_ = const_cast< ::bgs::protocol::user_manager::v1::BlockedPlayer*>(&::bgs::protocol::user_manager::v1::BlockedPlayer::default_instance()); + game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); + account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +BlockedPlayerRemovedNotification::BlockedPlayerRemovedNotification(const BlockedPlayerRemovedNotification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification) +} + +void BlockedPlayerRemovedNotification::SharedCtor() { + _cached_size_ = 0; + player_ = NULL; + game_account_id_ = NULL; + account_id_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +BlockedPlayerRemovedNotification::~BlockedPlayerRemovedNotification() { + // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification) + SharedDtor(); +} + +void BlockedPlayerRemovedNotification::SharedDtor() { + if (this != default_instance_) { + delete player_; + delete game_account_id_; + delete account_id_; + } +} + +void BlockedPlayerRemovedNotification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* BlockedPlayerRemovedNotification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return BlockedPlayerRemovedNotification_descriptor_; +} + +const BlockedPlayerRemovedNotification& BlockedPlayerRemovedNotification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + return *default_instance_; +} + +BlockedPlayerRemovedNotification* BlockedPlayerRemovedNotification::default_instance_ = NULL; + +BlockedPlayerRemovedNotification* BlockedPlayerRemovedNotification::New() const { + return new BlockedPlayerRemovedNotification; +} + +void BlockedPlayerRemovedNotification::Clear() { + if (_has_bits_[0 / 32] & 7) { + if (has_player()) { + if (player_ != NULL) player_->::bgs::protocol::user_manager::v1::BlockedPlayer::Clear(); + } + if (has_game_account_id()) { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_account_id()) { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool BlockedPlayerRemovedNotification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification) + 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)) { + // required .bgs.protocol.user_manager.v1.BlockedPlayer player = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_player())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_game_account_id; + break; + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + case 2: { + if (tag == 18) { + parse_game_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_game_account_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(26)) goto parse_account_id; + break; + } + + // optional .bgs.protocol.EntityId account_id = 3; + case 3: { + if (tag == 26) { + parse_account_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account_id())); + } 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:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification) + return false; +#undef DO_ +} + +void BlockedPlayerRemovedNotification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification) + // required .bgs.protocol.user_manager.v1.BlockedPlayer player = 1; + if (has_player()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->player(), output); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->game_account_id(), output); + } + + // optional .bgs.protocol.EntityId account_id = 3; + if (has_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->account_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification) +} + +::google::protobuf::uint8* BlockedPlayerRemovedNotification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification) + // required .bgs.protocol.user_manager.v1.BlockedPlayer player = 1; + if (has_player()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->player(), target); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->game_account_id(), target); + } + + // optional .bgs.protocol.EntityId account_id = 3; + if (has_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->account_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification) + return target; +} + +int BlockedPlayerRemovedNotification::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.user_manager.v1.BlockedPlayer player = 1; + if (has_player()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->player()); + } + + // optional .bgs.protocol.EntityId game_account_id = 2; + if (has_game_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->game_account_id()); + } + + // optional .bgs.protocol.EntityId account_id = 3; + if (has_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void BlockedPlayerRemovedNotification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const BlockedPlayerRemovedNotification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void BlockedPlayerRemovedNotification::MergeFrom(const BlockedPlayerRemovedNotification& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_player()) { + mutable_player()->::bgs::protocol::user_manager::v1::BlockedPlayer::MergeFrom(from.player()); + } + if (from.has_game_account_id()) { + mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id()); + } + if (from.has_account_id()) { + mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void BlockedPlayerRemovedNotification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void BlockedPlayerRemovedNotification::CopyFrom(const BlockedPlayerRemovedNotification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BlockedPlayerRemovedNotification::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_player()) { + if (!this->player().IsInitialized()) return false; + } + if (has_game_account_id()) { + if (!this->game_account_id().IsInitialized()) return false; + } + if (has_account_id()) { + if (!this->account_id().IsInitialized()) return false; + } + return true; +} + +void BlockedPlayerRemovedNotification::Swap(BlockedPlayerRemovedNotification* other) { + if (other != this) { + std::swap(player_, other->player_); + std::swap(game_account_id_, other->game_account_id_); + std::swap(account_id_, other->account_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata BlockedPlayerRemovedNotification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = BlockedPlayerRemovedNotification_descriptor_; + metadata.reflection = BlockedPlayerRemovedNotification_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int RecentPlayersAddedNotification::kPlayerFieldNumber; +#endif // !_MSC_VER + +RecentPlayersAddedNotification::RecentPlayersAddedNotification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification) +} + +void RecentPlayersAddedNotification::InitAsDefaultInstance() { +} + +RecentPlayersAddedNotification::RecentPlayersAddedNotification(const RecentPlayersAddedNotification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification) +} + +void RecentPlayersAddedNotification::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +RecentPlayersAddedNotification::~RecentPlayersAddedNotification() { + // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification) + SharedDtor(); +} + +void RecentPlayersAddedNotification::SharedDtor() { + if (this != default_instance_) { + } +} + +void RecentPlayersAddedNotification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* RecentPlayersAddedNotification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return RecentPlayersAddedNotification_descriptor_; +} + +const RecentPlayersAddedNotification& RecentPlayersAddedNotification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + return *default_instance_; +} + +RecentPlayersAddedNotification* RecentPlayersAddedNotification::default_instance_ = NULL; + +RecentPlayersAddedNotification* RecentPlayersAddedNotification::New() const { + return new RecentPlayersAddedNotification; +} + +void RecentPlayersAddedNotification::Clear() { + player_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool RecentPlayersAddedNotification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification) + 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 .bgs.protocol.user_manager.v1.RecentPlayer player = 1; + case 1: { + if (tag == 10) { + parse_player: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_player())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_player; + 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:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification) + return false; +#undef DO_ +} + +void RecentPlayersAddedNotification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification) + // repeated .bgs.protocol.user_manager.v1.RecentPlayer player = 1; + for (int i = 0; i < this->player_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->player(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification) +} + +::google::protobuf::uint8* RecentPlayersAddedNotification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification) + // repeated .bgs.protocol.user_manager.v1.RecentPlayer player = 1; + for (int i = 0; i < this->player_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->player(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification) + return target; +} + +int RecentPlayersAddedNotification::ByteSize() const { + int total_size = 0; + + // repeated .bgs.protocol.user_manager.v1.RecentPlayer player = 1; + total_size += 1 * this->player_size(); + for (int i = 0; i < this->player_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->player(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 RecentPlayersAddedNotification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const RecentPlayersAddedNotification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void RecentPlayersAddedNotification::MergeFrom(const RecentPlayersAddedNotification& from) { + GOOGLE_CHECK_NE(&from, this); + player_.MergeFrom(from.player_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void RecentPlayersAddedNotification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RecentPlayersAddedNotification::CopyFrom(const RecentPlayersAddedNotification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RecentPlayersAddedNotification::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->player())) return false; + return true; +} + +void RecentPlayersAddedNotification::Swap(RecentPlayersAddedNotification* other) { + if (other != this) { + player_.Swap(&other->player_); + 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 RecentPlayersAddedNotification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = RecentPlayersAddedNotification_descriptor_; + metadata.reflection = RecentPlayersAddedNotification_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int RecentPlayersRemovedNotification::kPlayerFieldNumber; +#endif // !_MSC_VER + +RecentPlayersRemovedNotification::RecentPlayersRemovedNotification() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification) +} + +void RecentPlayersRemovedNotification::InitAsDefaultInstance() { +} + +RecentPlayersRemovedNotification::RecentPlayersRemovedNotification(const RecentPlayersRemovedNotification& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification) +} + +void RecentPlayersRemovedNotification::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +RecentPlayersRemovedNotification::~RecentPlayersRemovedNotification() { + // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification) + SharedDtor(); +} + +void RecentPlayersRemovedNotification::SharedDtor() { + if (this != default_instance_) { + } +} + +void RecentPlayersRemovedNotification::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* RecentPlayersRemovedNotification::descriptor() { + protobuf_AssignDescriptorsOnce(); + return RecentPlayersRemovedNotification_descriptor_; +} + +const RecentPlayersRemovedNotification& RecentPlayersRemovedNotification::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + return *default_instance_; +} + +RecentPlayersRemovedNotification* RecentPlayersRemovedNotification::default_instance_ = NULL; + +RecentPlayersRemovedNotification* RecentPlayersRemovedNotification::New() const { + return new RecentPlayersRemovedNotification; +} + +void RecentPlayersRemovedNotification::Clear() { + player_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool RecentPlayersRemovedNotification::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification) + 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 .bgs.protocol.user_manager.v1.RecentPlayer player = 1; + case 1: { + if (tag == 10) { + parse_player: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_player())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(10)) goto parse_player; + 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:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification) + return false; +#undef DO_ +} + +void RecentPlayersRemovedNotification::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification) + // repeated .bgs.protocol.user_manager.v1.RecentPlayer player = 1; + for (int i = 0; i < this->player_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->player(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification) +} + +::google::protobuf::uint8* RecentPlayersRemovedNotification::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification) + // repeated .bgs.protocol.user_manager.v1.RecentPlayer player = 1; + for (int i = 0; i < this->player_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->player(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification) + return target; +} + +int RecentPlayersRemovedNotification::ByteSize() const { + int total_size = 0; + + // repeated .bgs.protocol.user_manager.v1.RecentPlayer player = 1; + total_size += 1 * this->player_size(); + for (int i = 0; i < this->player_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->player(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 RecentPlayersRemovedNotification::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const RecentPlayersRemovedNotification* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void RecentPlayersRemovedNotification::MergeFrom(const RecentPlayersRemovedNotification& from) { + GOOGLE_CHECK_NE(&from, this); + player_.MergeFrom(from.player_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void RecentPlayersRemovedNotification::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RecentPlayersRemovedNotification::CopyFrom(const RecentPlayersRemovedNotification& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RecentPlayersRemovedNotification::IsInitialized() const { + + if (!::google::protobuf::internal::AllAreInitialized(this->player())) return false; + return true; +} + +void RecentPlayersRemovedNotification::Swap(RecentPlayersRemovedNotification* other) { + if (other != this) { + player_.Swap(&other->player_); + 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 RecentPlayersRemovedNotification::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = RecentPlayersRemovedNotification_descriptor_; + metadata.reflection = RecentPlayersRemovedNotification_reflection_; + return metadata; +} + + +// =================================================================== + +google::protobuf::ServiceDescriptor const* UserManagerService::descriptor() { + protobuf_AssignDescriptorsOnce(); + return UserManagerService_descriptor_; +} + +void UserManagerService::Subscribe(::bgs::protocol::user_manager::v1::SubscribeRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerService.Subscribe(bgs.protocol.user_manager.v1.SubscribeRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 1, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::user_manager::v1::SubscribeResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void UserManagerService::AddRecentPlayers(::bgs::protocol::user_manager::v1::AddRecentPlayersRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerService.AddRecentPlayers(bgs.protocol.user_manager.v1.AddRecentPlayersRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 10, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::user_manager::v1::AddRecentPlayersResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void UserManagerService::ClearRecentPlayers(::bgs::protocol::user_manager::v1::ClearRecentPlayersRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerService.ClearRecentPlayers(bgs.protocol.user_manager.v1.ClearRecentPlayersRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 11, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::user_manager::v1::ClearRecentPlayersResponse response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void UserManagerService::BlockPlayer(::bgs::protocol::user_manager::v1::BlockPlayerRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerService.BlockPlayer(bgs.protocol.user_manager.v1.BlockPlayerRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 20, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void UserManagerService::UnblockPlayer(::bgs::protocol::user_manager::v1::UnblockPlayerRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerService.UnblockPlayer(bgs.protocol.user_manager.v1.UnblockPlayerRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 21, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void UserManagerService::BlockPlayerForSession(::bgs::protocol::user_manager::v1::BlockPlayerRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerService.BlockPlayerForSession(bgs.protocol.user_manager.v1.BlockPlayerRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 40, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void UserManagerService::LoadBlockList(::bgs::protocol::EntityId const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerService.LoadBlockList(bgs.protocol.EntityId{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 50, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void UserManagerService::Unsubscribe(::bgs::protocol::user_manager::v1::UnsubscribeRequest const* request, std::function responseCallback) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerService.Unsubscribe(bgs.protocol.user_manager.v1.UnsubscribeRequest{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 51, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) { + ::bgs::protocol::NoData response; + if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) + callback(&response); + }); +} + +void UserManagerService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) { + switch(methodId) { + case 1: { + ::bgs::protocol::user_manager::v1::SubscribeRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerService.Subscribe server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::user_manager::v1::SubscribeResponse response; + uint32 status = HandleSubscribe(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerService.Subscribe(bgs.protocol.user_manager.v1.SubscribeRequest{ %s }) returned bgs.protocol.user_manager.v1.SubscribeResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 1, token, &response); + else + SendResponse(service_hash_, 1, token, status); + break; + } + case 10: { + ::bgs::protocol::user_manager::v1::AddRecentPlayersRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerService.AddRecentPlayers server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 10, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::user_manager::v1::AddRecentPlayersResponse response; + uint32 status = HandleAddRecentPlayers(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerService.AddRecentPlayers(bgs.protocol.user_manager.v1.AddRecentPlayersRequest{ %s }) returned bgs.protocol.user_manager.v1.AddRecentPlayersResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 10, token, &response); + else + SendResponse(service_hash_, 10, token, status); + break; + } + case 11: { + ::bgs::protocol::user_manager::v1::ClearRecentPlayersRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerService.ClearRecentPlayers server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 11, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::user_manager::v1::ClearRecentPlayersResponse response; + uint32 status = HandleClearRecentPlayers(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerService.ClearRecentPlayers(bgs.protocol.user_manager.v1.ClearRecentPlayersRequest{ %s }) returned bgs.protocol.user_manager.v1.ClearRecentPlayersResponse{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 11, token, &response); + else + SendResponse(service_hash_, 11, token, status); + break; + } + case 20: { + ::bgs::protocol::user_manager::v1::BlockPlayerRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerService.BlockPlayer server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 20, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleBlockPlayer(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerService.BlockPlayer(bgs.protocol.user_manager.v1.BlockPlayerRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 20, token, &response); + else + SendResponse(service_hash_, 20, token, status); + break; + } + case 21: { + ::bgs::protocol::user_manager::v1::UnblockPlayerRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerService.UnblockPlayer server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 21, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleUnblockPlayer(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerService.UnblockPlayer(bgs.protocol.user_manager.v1.UnblockPlayerRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 21, token, &response); + else + SendResponse(service_hash_, 21, token, status); + break; + } + case 40: { + ::bgs::protocol::user_manager::v1::BlockPlayerRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerService.BlockPlayerForSession server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 40, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleBlockPlayerForSession(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerService.BlockPlayerForSession(bgs.protocol.user_manager.v1.BlockPlayerRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 40, token, &response); + else + SendResponse(service_hash_, 40, token, status); + break; + } + case 50: { + ::bgs::protocol::EntityId request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerService.LoadBlockList server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 50, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleLoadBlockList(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerService.LoadBlockList(bgs.protocol.EntityId{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 50, token, &response); + else + SendResponse(service_hash_, 50, token, status); + break; + } + case 51: { + ::bgs::protocol::user_manager::v1::UnsubscribeRequest request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerService.Unsubscribe server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 51, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + ::bgs::protocol::NoData response; + uint32 status = HandleUnsubscribe(&request, &response); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerService.Unsubscribe(bgs.protocol.user_manager.v1.UnsubscribeRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status); + if (!status) + SendResponse(service_hash_, 51, token, &response); + else + SendResponse(service_hash_, 51, token, status); + break; + } + default: + TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId); + SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD); + break; + } +} + +uint32 UserManagerService::HandleSubscribe(::bgs::protocol::user_manager::v1::SubscribeRequest const* request, ::bgs::protocol::user_manager::v1::SubscribeResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerService.Subscribe({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 UserManagerService::HandleAddRecentPlayers(::bgs::protocol::user_manager::v1::AddRecentPlayersRequest const* request, ::bgs::protocol::user_manager::v1::AddRecentPlayersResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerService.AddRecentPlayers({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 UserManagerService::HandleClearRecentPlayers(::bgs::protocol::user_manager::v1::ClearRecentPlayersRequest const* request, ::bgs::protocol::user_manager::v1::ClearRecentPlayersResponse* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerService.ClearRecentPlayers({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 UserManagerService::HandleBlockPlayer(::bgs::protocol::user_manager::v1::BlockPlayerRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerService.BlockPlayer({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 UserManagerService::HandleUnblockPlayer(::bgs::protocol::user_manager::v1::UnblockPlayerRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerService.UnblockPlayer({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 UserManagerService::HandleBlockPlayerForSession(::bgs::protocol::user_manager::v1::BlockPlayerRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerService.BlockPlayerForSession({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 UserManagerService::HandleLoadBlockList(::bgs::protocol::EntityId const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerService.LoadBlockList({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 UserManagerService::HandleUnsubscribe(::bgs::protocol::user_manager::v1::UnsubscribeRequest const* request, ::bgs::protocol::NoData* response) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerService.Unsubscribe({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +// =================================================================== + +google::protobuf::ServiceDescriptor const* UserManagerListener::descriptor() { + protobuf_AssignDescriptorsOnce(); + return UserManagerListener_descriptor_; +} + +void UserManagerListener::OnBlockedPlayerAdded(::bgs::protocol::user_manager::v1::BlockedPlayerAddedNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerListener.OnBlockedPlayerAdded(bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 1, request); +} + +void UserManagerListener::OnBlockedPlayerRemoved(::bgs::protocol::user_manager::v1::BlockedPlayerRemovedNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerListener.OnBlockedPlayerRemoved(bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 2, request); +} + +void UserManagerListener::OnRecentPlayersAdded(::bgs::protocol::user_manager::v1::RecentPlayersAddedNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerListener.OnRecentPlayersAdded(bgs.protocol.user_manager.v1.RecentPlayersAddedNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 11, request); +} + +void UserManagerListener::OnRecentPlayersRemoved(::bgs::protocol::user_manager::v1::RecentPlayersRemovedNotification const* request) { + TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerListener.OnRecentPlayersRemoved(bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification{ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + SendRequest(service_hash_, 12, request); +} + +void UserManagerListener::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) { + switch(methodId) { + case 1: { + ::bgs::protocol::user_manager::v1::BlockedPlayerAddedNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerListener.OnBlockedPlayerAdded server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnBlockedPlayerAdded(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerListener.OnBlockedPlayerAdded(bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 1, token, status); + break; + } + case 2: { + ::bgs::protocol::user_manager::v1::BlockedPlayerRemovedNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerListener.OnBlockedPlayerRemoved server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnBlockedPlayerRemoved(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerListener.OnBlockedPlayerRemoved(bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 2, token, status); + break; + } + case 11: { + ::bgs::protocol::user_manager::v1::RecentPlayersAddedNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerListener.OnRecentPlayersAdded server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 11, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnRecentPlayersAdded(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerListener.OnRecentPlayersAdded(bgs.protocol.user_manager.v1.RecentPlayersAddedNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 11, token, status); + break; + } + case 12: { + ::bgs::protocol::user_manager::v1::RecentPlayersRemovedNotification request; + if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) { + TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerListener.OnRecentPlayersRemoved server method call.", GetCallerInfo().c_str()); + SendResponse(service_hash_, 12, token, ERROR_RPC_MALFORMED_REQUEST); + return; + } + + uint32 status = HandleOnRecentPlayersRemoved(&request); + TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerListener.OnRecentPlayersRemoved(bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification{ %s }) status %u.", + GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status); + if (status) + SendResponse(service_hash_, 12, token, status); + break; + } + default: + TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId); + SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD); + break; + } +} + +uint32 UserManagerListener::HandleOnBlockedPlayerAdded(::bgs::protocol::user_manager::v1::BlockedPlayerAddedNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerListener.OnBlockedPlayerAdded({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 UserManagerListener::HandleOnBlockedPlayerRemoved(::bgs::protocol::user_manager::v1::BlockedPlayerRemovedNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerListener.OnBlockedPlayerRemoved({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 UserManagerListener::HandleOnRecentPlayersAdded(::bgs::protocol::user_manager::v1::RecentPlayersAddedNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerListener.OnRecentPlayersAdded({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + +uint32 UserManagerListener::HandleOnRecentPlayersRemoved(::bgs::protocol::user_manager::v1::RecentPlayersRemovedNotification const* request) { + TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerListener.OnRecentPlayersRemoved({ %s })", + GetCallerInfo().c_str(), request->ShortDebugString().c_str()); + return ERROR_RPC_NOT_IMPLEMENTED; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace user_manager +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/user_manager_service.pb.h b/src/server/proto/Client/user_manager_service.pb.h new file mode 100644 index 00000000000..a51ac759561 --- /dev/null +++ b/src/server/proto/Client/user_manager_service.pb.h @@ -0,0 +1,2411 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: user_manager_service.proto + +#ifndef PROTOBUF_user_5fmanager_5fservice_2eproto__INCLUDED +#define PROTOBUF_user_5fmanager_5fservice_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include "user_manager_types.pb.h" +#include "entity_types.pb.h" +#include "role_types.pb.h" +#include "rpc_types.pb.h" +#include "ServiceBase.h" +#include "MessageBuffer.h" +#include +#include +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { +namespace user_manager { +namespace v1 { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); +void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto(); +void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto(); + +class SubscribeRequest; +class SubscribeResponse; +class UnsubscribeRequest; +class AddRecentPlayersRequest; +class AddRecentPlayersResponse; +class ClearRecentPlayersRequest; +class ClearRecentPlayersResponse; +class BlockPlayerRequest; +class UnblockPlayerRequest; +class BlockedPlayerAddedNotification; +class BlockedPlayerRemovedNotification; +class RecentPlayersAddedNotification; +class RecentPlayersRemovedNotification; + +// =================================================================== + +class TC_SHARED_API SubscribeRequest : public ::google::protobuf::Message { + public: + SubscribeRequest(); + virtual ~SubscribeRequest(); + + SubscribeRequest(const SubscribeRequest& from); + + inline SubscribeRequest& operator=(const SubscribeRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SubscribeRequest& default_instance(); + + void Swap(SubscribeRequest* other); + + // implements Message ---------------------------------------------- + + SubscribeRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SubscribeRequest& from); + void MergeFrom(const SubscribeRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // required uint64 object_id = 2; + inline bool has_object_id() const; + inline void clear_object_id(); + static const int kObjectIdFieldNumber = 2; + inline ::google::protobuf::uint64 object_id() const; + inline void set_object_id(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.SubscribeRequest) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_object_id(); + inline void clear_has_object_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::google::protobuf::uint64 object_id_; + friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static SubscribeRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API SubscribeResponse : public ::google::protobuf::Message { + public: + SubscribeResponse(); + virtual ~SubscribeResponse(); + + SubscribeResponse(const SubscribeResponse& from); + + inline SubscribeResponse& operator=(const SubscribeResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SubscribeResponse& default_instance(); + + void Swap(SubscribeResponse* other); + + // implements Message ---------------------------------------------- + + SubscribeResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const SubscribeResponse& from); + void MergeFrom(const SubscribeResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.user_manager.v1.BlockedPlayer blocked_players = 1; + inline int blocked_players_size() const; + inline void clear_blocked_players(); + static const int kBlockedPlayersFieldNumber = 1; + inline const ::bgs::protocol::user_manager::v1::BlockedPlayer& blocked_players(int index) const; + inline ::bgs::protocol::user_manager::v1::BlockedPlayer* mutable_blocked_players(int index); + inline ::bgs::protocol::user_manager::v1::BlockedPlayer* add_blocked_players(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::BlockedPlayer >& + blocked_players() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::BlockedPlayer >* + mutable_blocked_players(); + + // repeated .bgs.protocol.user_manager.v1.RecentPlayer recent_players = 2; + inline int recent_players_size() const; + inline void clear_recent_players(); + static const int kRecentPlayersFieldNumber = 2; + inline const ::bgs::protocol::user_manager::v1::RecentPlayer& recent_players(int index) const; + inline ::bgs::protocol::user_manager::v1::RecentPlayer* mutable_recent_players(int index); + inline ::bgs::protocol::user_manager::v1::RecentPlayer* add_recent_players(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >& + recent_players() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >* + mutable_recent_players(); + + // repeated .bgs.protocol.Role role = 3; + inline int role_size() const; + inline void clear_role(); + static const int kRoleFieldNumber = 3; + inline const ::bgs::protocol::Role& role(int index) const; + inline ::bgs::protocol::Role* mutable_role(int index); + inline ::bgs::protocol::Role* add_role(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Role >& + role() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Role >* + mutable_role(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.SubscribeResponse) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::BlockedPlayer > blocked_players_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer > recent_players_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Role > role_; + friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static SubscribeResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API UnsubscribeRequest : public ::google::protobuf::Message { + public: + UnsubscribeRequest(); + virtual ~UnsubscribeRequest(); + + UnsubscribeRequest(const UnsubscribeRequest& from); + + inline UnsubscribeRequest& operator=(const UnsubscribeRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const UnsubscribeRequest& default_instance(); + + void Swap(UnsubscribeRequest* other); + + // implements Message ---------------------------------------------- + + UnsubscribeRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const UnsubscribeRequest& from); + void MergeFrom(const UnsubscribeRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // optional uint64 object_id = 2; + inline bool has_object_id() const; + inline void clear_object_id(); + static const int kObjectIdFieldNumber = 2; + inline ::google::protobuf::uint64 object_id() const; + inline void set_object_id(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.UnsubscribeRequest) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_object_id(); + inline void clear_has_object_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::google::protobuf::uint64 object_id_; + friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static UnsubscribeRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API AddRecentPlayersRequest : public ::google::protobuf::Message { + public: + AddRecentPlayersRequest(); + virtual ~AddRecentPlayersRequest(); + + AddRecentPlayersRequest(const AddRecentPlayersRequest& from); + + inline AddRecentPlayersRequest& operator=(const AddRecentPlayersRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AddRecentPlayersRequest& default_instance(); + + void Swap(AddRecentPlayersRequest* other); + + // implements Message ---------------------------------------------- + + AddRecentPlayersRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AddRecentPlayersRequest& from); + void MergeFrom(const AddRecentPlayersRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.user_manager.v1.RecentPlayer players = 1; + inline int players_size() const; + inline void clear_players(); + static const int kPlayersFieldNumber = 1; + inline const ::bgs::protocol::user_manager::v1::RecentPlayer& players(int index) const; + inline ::bgs::protocol::user_manager::v1::RecentPlayer* mutable_players(int index); + inline ::bgs::protocol::user_manager::v1::RecentPlayer* add_players(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >& + players() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >* + mutable_players(); + + // optional .bgs.protocol.EntityId agent_id = 2; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // optional uint32 program = 3; + inline bool has_program() const; + inline void clear_program(); + static const int kProgramFieldNumber = 3; + inline ::google::protobuf::uint32 program() const; + inline void set_program(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.AddRecentPlayersRequest) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_program(); + inline void clear_has_program(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer > players_; + ::bgs::protocol::EntityId* agent_id_; + ::google::protobuf::uint32 program_; + friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static AddRecentPlayersRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API AddRecentPlayersResponse : public ::google::protobuf::Message { + public: + AddRecentPlayersResponse(); + virtual ~AddRecentPlayersResponse(); + + AddRecentPlayersResponse(const AddRecentPlayersResponse& from); + + inline AddRecentPlayersResponse& operator=(const AddRecentPlayersResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AddRecentPlayersResponse& default_instance(); + + void Swap(AddRecentPlayersResponse* other); + + // implements Message ---------------------------------------------- + + AddRecentPlayersResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AddRecentPlayersResponse& from); + void MergeFrom(const AddRecentPlayersResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.user_manager.v1.RecentPlayer players_added = 1; + inline int players_added_size() const; + inline void clear_players_added(); + static const int kPlayersAddedFieldNumber = 1; + inline const ::bgs::protocol::user_manager::v1::RecentPlayer& players_added(int index) const; + inline ::bgs::protocol::user_manager::v1::RecentPlayer* mutable_players_added(int index); + inline ::bgs::protocol::user_manager::v1::RecentPlayer* add_players_added(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >& + players_added() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >* + mutable_players_added(); + + // repeated fixed32 players_removed = 3; + inline int players_removed_size() const; + inline void clear_players_removed(); + static const int kPlayersRemovedFieldNumber = 3; + inline ::google::protobuf::uint32 players_removed(int index) const; + inline void set_players_removed(int index, ::google::protobuf::uint32 value); + inline void add_players_removed(::google::protobuf::uint32 value); + inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + players_removed() const; + inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_players_removed(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.AddRecentPlayersResponse) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer > players_added_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > players_removed_; + friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static AddRecentPlayersResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ClearRecentPlayersRequest : public ::google::protobuf::Message { + public: + ClearRecentPlayersRequest(); + virtual ~ClearRecentPlayersRequest(); + + ClearRecentPlayersRequest(const ClearRecentPlayersRequest& from); + + inline ClearRecentPlayersRequest& operator=(const ClearRecentPlayersRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ClearRecentPlayersRequest& default_instance(); + + void Swap(ClearRecentPlayersRequest* other); + + // implements Message ---------------------------------------------- + + ClearRecentPlayersRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ClearRecentPlayersRequest& from); + void MergeFrom(const ClearRecentPlayersRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // optional uint32 program = 2; + inline bool has_program() const; + inline void clear_program(); + static const int kProgramFieldNumber = 2; + inline ::google::protobuf::uint32 program() const; + inline void set_program(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_program(); + inline void clear_has_program(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::google::protobuf::uint32 program_; + friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ClearRecentPlayersRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API ClearRecentPlayersResponse : public ::google::protobuf::Message { + public: + ClearRecentPlayersResponse(); + virtual ~ClearRecentPlayersResponse(); + + ClearRecentPlayersResponse(const ClearRecentPlayersResponse& from); + + inline ClearRecentPlayersResponse& operator=(const ClearRecentPlayersResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ClearRecentPlayersResponse& default_instance(); + + void Swap(ClearRecentPlayersResponse* other); + + // implements Message ---------------------------------------------- + + ClearRecentPlayersResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ClearRecentPlayersResponse& from); + void MergeFrom(const ClearRecentPlayersResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated fixed32 players_removed = 1; + inline int players_removed_size() const; + inline void clear_players_removed(); + static const int kPlayersRemovedFieldNumber = 1; + inline ::google::protobuf::uint32 players_removed(int index) const; + inline void set_players_removed(int index, ::google::protobuf::uint32 value); + inline void add_players_removed(::google::protobuf::uint32 value); + inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + players_removed() const; + inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_players_removed(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > players_removed_; + friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static ClearRecentPlayersResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API BlockPlayerRequest : public ::google::protobuf::Message { + public: + BlockPlayerRequest(); + virtual ~BlockPlayerRequest(); + + BlockPlayerRequest(const BlockPlayerRequest& from); + + inline BlockPlayerRequest& operator=(const BlockPlayerRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const BlockPlayerRequest& default_instance(); + + void Swap(BlockPlayerRequest* other); + + // implements Message ---------------------------------------------- + + BlockPlayerRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const BlockPlayerRequest& from); + void MergeFrom(const BlockPlayerRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // required .bgs.protocol.EntityId target_id = 2; + inline bool has_target_id() const; + inline void clear_target_id(); + static const int kTargetIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& target_id() const; + inline ::bgs::protocol::EntityId* mutable_target_id(); + inline ::bgs::protocol::EntityId* release_target_id(); + inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id); + + // optional uint32 role = 3; + inline bool has_role() const; + inline void clear_role(); + static const int kRoleFieldNumber = 3; + inline ::google::protobuf::uint32 role() const; + inline void set_role(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.BlockPlayerRequest) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_target_id(); + inline void clear_has_target_id(); + inline void set_has_role(); + inline void clear_has_role(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::bgs::protocol::EntityId* target_id_; + ::google::protobuf::uint32 role_; + friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static BlockPlayerRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API UnblockPlayerRequest : public ::google::protobuf::Message { + public: + UnblockPlayerRequest(); + virtual ~UnblockPlayerRequest(); + + UnblockPlayerRequest(const UnblockPlayerRequest& from); + + inline UnblockPlayerRequest& operator=(const UnblockPlayerRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const UnblockPlayerRequest& default_instance(); + + void Swap(UnblockPlayerRequest* other); + + // implements Message ---------------------------------------------- + + UnblockPlayerRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const UnblockPlayerRequest& from); + void MergeFrom(const UnblockPlayerRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .bgs.protocol.EntityId agent_id = 1; + inline bool has_agent_id() const; + inline void clear_agent_id(); + static const int kAgentIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& agent_id() const; + inline ::bgs::protocol::EntityId* mutable_agent_id(); + inline ::bgs::protocol::EntityId* release_agent_id(); + inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id); + + // required .bgs.protocol.EntityId target_id = 2; + inline bool has_target_id() const; + inline void clear_target_id(); + static const int kTargetIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& target_id() const; + inline ::bgs::protocol::EntityId* mutable_target_id(); + inline ::bgs::protocol::EntityId* release_target_id(); + inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id); + + // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.UnblockPlayerRequest) + private: + inline void set_has_agent_id(); + inline void clear_has_agent_id(); + inline void set_has_target_id(); + inline void clear_has_target_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* agent_id_; + ::bgs::protocol::EntityId* target_id_; + friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static UnblockPlayerRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API BlockedPlayerAddedNotification : public ::google::protobuf::Message { + public: + BlockedPlayerAddedNotification(); + virtual ~BlockedPlayerAddedNotification(); + + BlockedPlayerAddedNotification(const BlockedPlayerAddedNotification& from); + + inline BlockedPlayerAddedNotification& operator=(const BlockedPlayerAddedNotification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const BlockedPlayerAddedNotification& default_instance(); + + void Swap(BlockedPlayerAddedNotification* other); + + // implements Message ---------------------------------------------- + + BlockedPlayerAddedNotification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const BlockedPlayerAddedNotification& from); + void MergeFrom(const BlockedPlayerAddedNotification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.user_manager.v1.BlockedPlayer player = 1; + inline bool has_player() const; + inline void clear_player(); + static const int kPlayerFieldNumber = 1; + inline const ::bgs::protocol::user_manager::v1::BlockedPlayer& player() const; + inline ::bgs::protocol::user_manager::v1::BlockedPlayer* mutable_player(); + inline ::bgs::protocol::user_manager::v1::BlockedPlayer* release_player(); + inline void set_allocated_player(::bgs::protocol::user_manager::v1::BlockedPlayer* player); + + // optional .bgs.protocol.EntityId game_account_id = 2; + inline bool has_game_account_id() const; + inline void clear_game_account_id(); + static const int kGameAccountIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& game_account_id() const; + inline ::bgs::protocol::EntityId* mutable_game_account_id(); + inline ::bgs::protocol::EntityId* release_game_account_id(); + inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id); + + // optional .bgs.protocol.EntityId account_id = 3; + inline bool has_account_id() const; + inline void clear_account_id(); + static const int kAccountIdFieldNumber = 3; + inline const ::bgs::protocol::EntityId& account_id() const; + inline ::bgs::protocol::EntityId* mutable_account_id(); + inline ::bgs::protocol::EntityId* release_account_id(); + inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id); + + // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification) + private: + inline void set_has_player(); + inline void clear_has_player(); + inline void set_has_game_account_id(); + inline void clear_has_game_account_id(); + inline void set_has_account_id(); + inline void clear_has_account_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::user_manager::v1::BlockedPlayer* player_; + ::bgs::protocol::EntityId* game_account_id_; + ::bgs::protocol::EntityId* account_id_; + friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static BlockedPlayerAddedNotification* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API BlockedPlayerRemovedNotification : public ::google::protobuf::Message { + public: + BlockedPlayerRemovedNotification(); + virtual ~BlockedPlayerRemovedNotification(); + + BlockedPlayerRemovedNotification(const BlockedPlayerRemovedNotification& from); + + inline BlockedPlayerRemovedNotification& operator=(const BlockedPlayerRemovedNotification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const BlockedPlayerRemovedNotification& default_instance(); + + void Swap(BlockedPlayerRemovedNotification* other); + + // implements Message ---------------------------------------------- + + BlockedPlayerRemovedNotification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const BlockedPlayerRemovedNotification& from); + void MergeFrom(const BlockedPlayerRemovedNotification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.user_manager.v1.BlockedPlayer player = 1; + inline bool has_player() const; + inline void clear_player(); + static const int kPlayerFieldNumber = 1; + inline const ::bgs::protocol::user_manager::v1::BlockedPlayer& player() const; + inline ::bgs::protocol::user_manager::v1::BlockedPlayer* mutable_player(); + inline ::bgs::protocol::user_manager::v1::BlockedPlayer* release_player(); + inline void set_allocated_player(::bgs::protocol::user_manager::v1::BlockedPlayer* player); + + // optional .bgs.protocol.EntityId game_account_id = 2; + inline bool has_game_account_id() const; + inline void clear_game_account_id(); + static const int kGameAccountIdFieldNumber = 2; + inline const ::bgs::protocol::EntityId& game_account_id() const; + inline ::bgs::protocol::EntityId* mutable_game_account_id(); + inline ::bgs::protocol::EntityId* release_game_account_id(); + inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id); + + // optional .bgs.protocol.EntityId account_id = 3; + inline bool has_account_id() const; + inline void clear_account_id(); + static const int kAccountIdFieldNumber = 3; + inline const ::bgs::protocol::EntityId& account_id() const; + inline ::bgs::protocol::EntityId* mutable_account_id(); + inline ::bgs::protocol::EntityId* release_account_id(); + inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id); + + // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification) + private: + inline void set_has_player(); + inline void clear_has_player(); + inline void set_has_game_account_id(); + inline void clear_has_game_account_id(); + inline void set_has_account_id(); + inline void clear_has_account_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::user_manager::v1::BlockedPlayer* player_; + ::bgs::protocol::EntityId* game_account_id_; + ::bgs::protocol::EntityId* account_id_; + friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static BlockedPlayerRemovedNotification* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API RecentPlayersAddedNotification : public ::google::protobuf::Message { + public: + RecentPlayersAddedNotification(); + virtual ~RecentPlayersAddedNotification(); + + RecentPlayersAddedNotification(const RecentPlayersAddedNotification& from); + + inline RecentPlayersAddedNotification& operator=(const RecentPlayersAddedNotification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const RecentPlayersAddedNotification& default_instance(); + + void Swap(RecentPlayersAddedNotification* other); + + // implements Message ---------------------------------------------- + + RecentPlayersAddedNotification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const RecentPlayersAddedNotification& from); + void MergeFrom(const RecentPlayersAddedNotification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.user_manager.v1.RecentPlayer player = 1; + inline int player_size() const; + inline void clear_player(); + static const int kPlayerFieldNumber = 1; + inline const ::bgs::protocol::user_manager::v1::RecentPlayer& player(int index) const; + inline ::bgs::protocol::user_manager::v1::RecentPlayer* mutable_player(int index); + inline ::bgs::protocol::user_manager::v1::RecentPlayer* add_player(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >& + player() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >* + mutable_player(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer > player_; + friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static RecentPlayersAddedNotification* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API RecentPlayersRemovedNotification : public ::google::protobuf::Message { + public: + RecentPlayersRemovedNotification(); + virtual ~RecentPlayersRemovedNotification(); + + RecentPlayersRemovedNotification(const RecentPlayersRemovedNotification& from); + + inline RecentPlayersRemovedNotification& operator=(const RecentPlayersRemovedNotification& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const RecentPlayersRemovedNotification& default_instance(); + + void Swap(RecentPlayersRemovedNotification* other); + + // implements Message ---------------------------------------------- + + RecentPlayersRemovedNotification* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const RecentPlayersRemovedNotification& from); + void MergeFrom(const RecentPlayersRemovedNotification& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .bgs.protocol.user_manager.v1.RecentPlayer player = 1; + inline int player_size() const; + inline void clear_player(); + static const int kPlayerFieldNumber = 1; + inline const ::bgs::protocol::user_manager::v1::RecentPlayer& player(int index) const; + inline ::bgs::protocol::user_manager::v1::RecentPlayer* mutable_player(int index); + inline ::bgs::protocol::user_manager::v1::RecentPlayer* add_player(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >& + player() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >* + mutable_player(); + + // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer > player_; + friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto(); + friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto(); + + void InitAsDefaultInstance(); + static RecentPlayersRemovedNotification* default_instance_; +}; +// =================================================================== + +class TC_SHARED_API UserManagerService : public ServiceBase +{ + public: + + template + explicit UserManagerService(HashSelector) : service_hash_(HashSelector::Result::value) { } + + typedef std::integral_constant OriginalHash; + typedef std::integral_constant NameHash; + + static google::protobuf::ServiceDescriptor const* descriptor(); + + // client methods -------------------------------------------------- + + void Subscribe(::bgs::protocol::user_manager::v1::SubscribeRequest const* request, std::function responseCallback); + void AddRecentPlayers(::bgs::protocol::user_manager::v1::AddRecentPlayersRequest const* request, std::function responseCallback); + void ClearRecentPlayers(::bgs::protocol::user_manager::v1::ClearRecentPlayersRequest const* request, std::function responseCallback); + void BlockPlayer(::bgs::protocol::user_manager::v1::BlockPlayerRequest const* request, std::function responseCallback); + void UnblockPlayer(::bgs::protocol::user_manager::v1::UnblockPlayerRequest const* request, std::function responseCallback); + void BlockPlayerForSession(::bgs::protocol::user_manager::v1::BlockPlayerRequest const* request, std::function responseCallback); + void LoadBlockList(::bgs::protocol::EntityId const* request, std::function responseCallback); + void Unsubscribe(::bgs::protocol::user_manager::v1::UnsubscribeRequest const* request, std::function responseCallback); + // server methods -------------------------------------------------- + + void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final; + + protected: + virtual uint32 HandleSubscribe(::bgs::protocol::user_manager::v1::SubscribeRequest const* request, ::bgs::protocol::user_manager::v1::SubscribeResponse* response); + virtual uint32 HandleAddRecentPlayers(::bgs::protocol::user_manager::v1::AddRecentPlayersRequest const* request, ::bgs::protocol::user_manager::v1::AddRecentPlayersResponse* response); + virtual uint32 HandleClearRecentPlayers(::bgs::protocol::user_manager::v1::ClearRecentPlayersRequest const* request, ::bgs::protocol::user_manager::v1::ClearRecentPlayersResponse* response); + virtual uint32 HandleBlockPlayer(::bgs::protocol::user_manager::v1::BlockPlayerRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleUnblockPlayer(::bgs::protocol::user_manager::v1::UnblockPlayerRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleBlockPlayerForSession(::bgs::protocol::user_manager::v1::BlockPlayerRequest const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleLoadBlockList(::bgs::protocol::EntityId const* request, ::bgs::protocol::NoData* response); + virtual uint32 HandleUnsubscribe(::bgs::protocol::user_manager::v1::UnsubscribeRequest const* request, ::bgs::protocol::NoData* response); + + private: + uint32 service_hash_; + + GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(UserManagerService); +}; + +// ------------------------------------------------------------------- + +class TC_SHARED_API UserManagerListener : public ServiceBase +{ + public: + + template + explicit UserManagerListener(HashSelector) : service_hash_(HashSelector::Result::value) { } + + typedef std::integral_constant OriginalHash; + typedef std::integral_constant NameHash; + + static google::protobuf::ServiceDescriptor const* descriptor(); + + // client methods -------------------------------------------------- + + void OnBlockedPlayerAdded(::bgs::protocol::user_manager::v1::BlockedPlayerAddedNotification const* request); + void OnBlockedPlayerRemoved(::bgs::protocol::user_manager::v1::BlockedPlayerRemovedNotification const* request); + void OnRecentPlayersAdded(::bgs::protocol::user_manager::v1::RecentPlayersAddedNotification const* request); + void OnRecentPlayersRemoved(::bgs::protocol::user_manager::v1::RecentPlayersRemovedNotification const* request); + // server methods -------------------------------------------------- + + void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final; + + protected: + virtual uint32 HandleOnBlockedPlayerAdded(::bgs::protocol::user_manager::v1::BlockedPlayerAddedNotification const* request); + virtual uint32 HandleOnBlockedPlayerRemoved(::bgs::protocol::user_manager::v1::BlockedPlayerRemovedNotification const* request); + virtual uint32 HandleOnRecentPlayersAdded(::bgs::protocol::user_manager::v1::RecentPlayersAddedNotification const* request); + virtual uint32 HandleOnRecentPlayersRemoved(::bgs::protocol::user_manager::v1::RecentPlayersRemovedNotification const* request); + + private: + uint32 service_hash_; + + GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(UserManagerListener); +}; + +// =================================================================== + + +// =================================================================== + +// SubscribeRequest + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool SubscribeRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SubscribeRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void SubscribeRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SubscribeRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& SubscribeRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.SubscribeRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* SubscribeRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.SubscribeRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* SubscribeRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void SubscribeRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.SubscribeRequest.agent_id) +} + +// required uint64 object_id = 2; +inline bool SubscribeRequest::has_object_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void SubscribeRequest::set_has_object_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void SubscribeRequest::clear_has_object_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void SubscribeRequest::clear_object_id() { + object_id_ = GOOGLE_ULONGLONG(0); + clear_has_object_id(); +} +inline ::google::protobuf::uint64 SubscribeRequest::object_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.SubscribeRequest.object_id) + return object_id_; +} +inline void SubscribeRequest::set_object_id(::google::protobuf::uint64 value) { + set_has_object_id(); + object_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.SubscribeRequest.object_id) +} + +// ------------------------------------------------------------------- + +// SubscribeResponse + +// repeated .bgs.protocol.user_manager.v1.BlockedPlayer blocked_players = 1; +inline int SubscribeResponse::blocked_players_size() const { + return blocked_players_.size(); +} +inline void SubscribeResponse::clear_blocked_players() { + blocked_players_.Clear(); +} +inline const ::bgs::protocol::user_manager::v1::BlockedPlayer& SubscribeResponse::blocked_players(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.SubscribeResponse.blocked_players) + return blocked_players_.Get(index); +} +inline ::bgs::protocol::user_manager::v1::BlockedPlayer* SubscribeResponse::mutable_blocked_players(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.SubscribeResponse.blocked_players) + return blocked_players_.Mutable(index); +} +inline ::bgs::protocol::user_manager::v1::BlockedPlayer* SubscribeResponse::add_blocked_players() { + // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.SubscribeResponse.blocked_players) + return blocked_players_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::BlockedPlayer >& +SubscribeResponse::blocked_players() const { + // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.SubscribeResponse.blocked_players) + return blocked_players_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::BlockedPlayer >* +SubscribeResponse::mutable_blocked_players() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.SubscribeResponse.blocked_players) + return &blocked_players_; +} + +// repeated .bgs.protocol.user_manager.v1.RecentPlayer recent_players = 2; +inline int SubscribeResponse::recent_players_size() const { + return recent_players_.size(); +} +inline void SubscribeResponse::clear_recent_players() { + recent_players_.Clear(); +} +inline const ::bgs::protocol::user_manager::v1::RecentPlayer& SubscribeResponse::recent_players(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.SubscribeResponse.recent_players) + return recent_players_.Get(index); +} +inline ::bgs::protocol::user_manager::v1::RecentPlayer* SubscribeResponse::mutable_recent_players(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.SubscribeResponse.recent_players) + return recent_players_.Mutable(index); +} +inline ::bgs::protocol::user_manager::v1::RecentPlayer* SubscribeResponse::add_recent_players() { + // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.SubscribeResponse.recent_players) + return recent_players_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >& +SubscribeResponse::recent_players() const { + // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.SubscribeResponse.recent_players) + return recent_players_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >* +SubscribeResponse::mutable_recent_players() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.SubscribeResponse.recent_players) + return &recent_players_; +} + +// repeated .bgs.protocol.Role role = 3; +inline int SubscribeResponse::role_size() const { + return role_.size(); +} +inline void SubscribeResponse::clear_role() { + role_.Clear(); +} +inline const ::bgs::protocol::Role& SubscribeResponse::role(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.SubscribeResponse.role) + return role_.Get(index); +} +inline ::bgs::protocol::Role* SubscribeResponse::mutable_role(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.SubscribeResponse.role) + return role_.Mutable(index); +} +inline ::bgs::protocol::Role* SubscribeResponse::add_role() { + // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.SubscribeResponse.role) + return role_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Role >& +SubscribeResponse::role() const { + // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.SubscribeResponse.role) + return role_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Role >* +SubscribeResponse::mutable_role() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.SubscribeResponse.role) + return &role_; +} + +// ------------------------------------------------------------------- + +// UnsubscribeRequest + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool UnsubscribeRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void UnsubscribeRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void UnsubscribeRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void UnsubscribeRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& UnsubscribeRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.UnsubscribeRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* UnsubscribeRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.UnsubscribeRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* UnsubscribeRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void UnsubscribeRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.UnsubscribeRequest.agent_id) +} + +// optional uint64 object_id = 2; +inline bool UnsubscribeRequest::has_object_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void UnsubscribeRequest::set_has_object_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void UnsubscribeRequest::clear_has_object_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void UnsubscribeRequest::clear_object_id() { + object_id_ = GOOGLE_ULONGLONG(0); + clear_has_object_id(); +} +inline ::google::protobuf::uint64 UnsubscribeRequest::object_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.UnsubscribeRequest.object_id) + return object_id_; +} +inline void UnsubscribeRequest::set_object_id(::google::protobuf::uint64 value) { + set_has_object_id(); + object_id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.UnsubscribeRequest.object_id) +} + +// ------------------------------------------------------------------- + +// AddRecentPlayersRequest + +// repeated .bgs.protocol.user_manager.v1.RecentPlayer players = 1; +inline int AddRecentPlayersRequest::players_size() const { + return players_.size(); +} +inline void AddRecentPlayersRequest::clear_players() { + players_.Clear(); +} +inline const ::bgs::protocol::user_manager::v1::RecentPlayer& AddRecentPlayersRequest::players(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.AddRecentPlayersRequest.players) + return players_.Get(index); +} +inline ::bgs::protocol::user_manager::v1::RecentPlayer* AddRecentPlayersRequest::mutable_players(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.AddRecentPlayersRequest.players) + return players_.Mutable(index); +} +inline ::bgs::protocol::user_manager::v1::RecentPlayer* AddRecentPlayersRequest::add_players() { + // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.AddRecentPlayersRequest.players) + return players_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >& +AddRecentPlayersRequest::players() const { + // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.AddRecentPlayersRequest.players) + return players_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >* +AddRecentPlayersRequest::mutable_players() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.AddRecentPlayersRequest.players) + return &players_; +} + +// optional .bgs.protocol.EntityId agent_id = 2; +inline bool AddRecentPlayersRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void AddRecentPlayersRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void AddRecentPlayersRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void AddRecentPlayersRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& AddRecentPlayersRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.AddRecentPlayersRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* AddRecentPlayersRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.AddRecentPlayersRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* AddRecentPlayersRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void AddRecentPlayersRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.AddRecentPlayersRequest.agent_id) +} + +// optional uint32 program = 3; +inline bool AddRecentPlayersRequest::has_program() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void AddRecentPlayersRequest::set_has_program() { + _has_bits_[0] |= 0x00000004u; +} +inline void AddRecentPlayersRequest::clear_has_program() { + _has_bits_[0] &= ~0x00000004u; +} +inline void AddRecentPlayersRequest::clear_program() { + program_ = 0u; + clear_has_program(); +} +inline ::google::protobuf::uint32 AddRecentPlayersRequest::program() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.AddRecentPlayersRequest.program) + return program_; +} +inline void AddRecentPlayersRequest::set_program(::google::protobuf::uint32 value) { + set_has_program(); + program_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.AddRecentPlayersRequest.program) +} + +// ------------------------------------------------------------------- + +// AddRecentPlayersResponse + +// repeated .bgs.protocol.user_manager.v1.RecentPlayer players_added = 1; +inline int AddRecentPlayersResponse::players_added_size() const { + return players_added_.size(); +} +inline void AddRecentPlayersResponse::clear_players_added() { + players_added_.Clear(); +} +inline const ::bgs::protocol::user_manager::v1::RecentPlayer& AddRecentPlayersResponse::players_added(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_added) + return players_added_.Get(index); +} +inline ::bgs::protocol::user_manager::v1::RecentPlayer* AddRecentPlayersResponse::mutable_players_added(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_added) + return players_added_.Mutable(index); +} +inline ::bgs::protocol::user_manager::v1::RecentPlayer* AddRecentPlayersResponse::add_players_added() { + // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_added) + return players_added_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >& +AddRecentPlayersResponse::players_added() const { + // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_added) + return players_added_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >* +AddRecentPlayersResponse::mutable_players_added() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_added) + return &players_added_; +} + +// repeated fixed32 players_removed = 3; +inline int AddRecentPlayersResponse::players_removed_size() const { + return players_removed_.size(); +} +inline void AddRecentPlayersResponse::clear_players_removed() { + players_removed_.Clear(); +} +inline ::google::protobuf::uint32 AddRecentPlayersResponse::players_removed(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_removed) + return players_removed_.Get(index); +} +inline void AddRecentPlayersResponse::set_players_removed(int index, ::google::protobuf::uint32 value) { + players_removed_.Set(index, value); + // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_removed) +} +inline void AddRecentPlayersResponse::add_players_removed(::google::protobuf::uint32 value) { + players_removed_.Add(value); + // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_removed) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +AddRecentPlayersResponse::players_removed() const { + // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_removed) + return players_removed_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +AddRecentPlayersResponse::mutable_players_removed() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_removed) + return &players_removed_; +} + +// ------------------------------------------------------------------- + +// ClearRecentPlayersRequest + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool ClearRecentPlayersRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ClearRecentPlayersRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void ClearRecentPlayersRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ClearRecentPlayersRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& ClearRecentPlayersRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* ClearRecentPlayersRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* ClearRecentPlayersRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void ClearRecentPlayersRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest.agent_id) +} + +// optional uint32 program = 2; +inline bool ClearRecentPlayersRequest::has_program() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ClearRecentPlayersRequest::set_has_program() { + _has_bits_[0] |= 0x00000002u; +} +inline void ClearRecentPlayersRequest::clear_has_program() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ClearRecentPlayersRequest::clear_program() { + program_ = 0u; + clear_has_program(); +} +inline ::google::protobuf::uint32 ClearRecentPlayersRequest::program() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest.program) + return program_; +} +inline void ClearRecentPlayersRequest::set_program(::google::protobuf::uint32 value) { + set_has_program(); + program_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest.program) +} + +// ------------------------------------------------------------------- + +// ClearRecentPlayersResponse + +// repeated fixed32 players_removed = 1; +inline int ClearRecentPlayersResponse::players_removed_size() const { + return players_removed_.size(); +} +inline void ClearRecentPlayersResponse::clear_players_removed() { + players_removed_.Clear(); +} +inline ::google::protobuf::uint32 ClearRecentPlayersResponse::players_removed(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse.players_removed) + return players_removed_.Get(index); +} +inline void ClearRecentPlayersResponse::set_players_removed(int index, ::google::protobuf::uint32 value) { + players_removed_.Set(index, value); + // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse.players_removed) +} +inline void ClearRecentPlayersResponse::add_players_removed(::google::protobuf::uint32 value) { + players_removed_.Add(value); + // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse.players_removed) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +ClearRecentPlayersResponse::players_removed() const { + // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse.players_removed) + return players_removed_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +ClearRecentPlayersResponse::mutable_players_removed() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse.players_removed) + return &players_removed_; +} + +// ------------------------------------------------------------------- + +// BlockPlayerRequest + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool BlockPlayerRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void BlockPlayerRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void BlockPlayerRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void BlockPlayerRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& BlockPlayerRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockPlayerRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* BlockPlayerRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.BlockPlayerRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* BlockPlayerRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void BlockPlayerRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.BlockPlayerRequest.agent_id) +} + +// required .bgs.protocol.EntityId target_id = 2; +inline bool BlockPlayerRequest::has_target_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void BlockPlayerRequest::set_has_target_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void BlockPlayerRequest::clear_has_target_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void BlockPlayerRequest::clear_target_id() { + if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear(); + clear_has_target_id(); +} +inline const ::bgs::protocol::EntityId& BlockPlayerRequest::target_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockPlayerRequest.target_id) + return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_; +} +inline ::bgs::protocol::EntityId* BlockPlayerRequest::mutable_target_id() { + set_has_target_id(); + if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.BlockPlayerRequest.target_id) + return target_id_; +} +inline ::bgs::protocol::EntityId* BlockPlayerRequest::release_target_id() { + clear_has_target_id(); + ::bgs::protocol::EntityId* temp = target_id_; + target_id_ = NULL; + return temp; +} +inline void BlockPlayerRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) { + delete target_id_; + target_id_ = target_id; + if (target_id) { + set_has_target_id(); + } else { + clear_has_target_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.BlockPlayerRequest.target_id) +} + +// optional uint32 role = 3; +inline bool BlockPlayerRequest::has_role() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void BlockPlayerRequest::set_has_role() { + _has_bits_[0] |= 0x00000004u; +} +inline void BlockPlayerRequest::clear_has_role() { + _has_bits_[0] &= ~0x00000004u; +} +inline void BlockPlayerRequest::clear_role() { + role_ = 0u; + clear_has_role(); +} +inline ::google::protobuf::uint32 BlockPlayerRequest::role() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockPlayerRequest.role) + return role_; +} +inline void BlockPlayerRequest::set_role(::google::protobuf::uint32 value) { + set_has_role(); + role_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.BlockPlayerRequest.role) +} + +// ------------------------------------------------------------------- + +// UnblockPlayerRequest + +// optional .bgs.protocol.EntityId agent_id = 1; +inline bool UnblockPlayerRequest::has_agent_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void UnblockPlayerRequest::set_has_agent_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void UnblockPlayerRequest::clear_has_agent_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void UnblockPlayerRequest::clear_agent_id() { + if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear(); + clear_has_agent_id(); +} +inline const ::bgs::protocol::EntityId& UnblockPlayerRequest::agent_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.UnblockPlayerRequest.agent_id) + return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_; +} +inline ::bgs::protocol::EntityId* UnblockPlayerRequest::mutable_agent_id() { + set_has_agent_id(); + if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.UnblockPlayerRequest.agent_id) + return agent_id_; +} +inline ::bgs::protocol::EntityId* UnblockPlayerRequest::release_agent_id() { + clear_has_agent_id(); + ::bgs::protocol::EntityId* temp = agent_id_; + agent_id_ = NULL; + return temp; +} +inline void UnblockPlayerRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) { + delete agent_id_; + agent_id_ = agent_id; + if (agent_id) { + set_has_agent_id(); + } else { + clear_has_agent_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.UnblockPlayerRequest.agent_id) +} + +// required .bgs.protocol.EntityId target_id = 2; +inline bool UnblockPlayerRequest::has_target_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void UnblockPlayerRequest::set_has_target_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void UnblockPlayerRequest::clear_has_target_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void UnblockPlayerRequest::clear_target_id() { + if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear(); + clear_has_target_id(); +} +inline const ::bgs::protocol::EntityId& UnblockPlayerRequest::target_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.UnblockPlayerRequest.target_id) + return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_; +} +inline ::bgs::protocol::EntityId* UnblockPlayerRequest::mutable_target_id() { + set_has_target_id(); + if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.UnblockPlayerRequest.target_id) + return target_id_; +} +inline ::bgs::protocol::EntityId* UnblockPlayerRequest::release_target_id() { + clear_has_target_id(); + ::bgs::protocol::EntityId* temp = target_id_; + target_id_ = NULL; + return temp; +} +inline void UnblockPlayerRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) { + delete target_id_; + target_id_ = target_id; + if (target_id) { + set_has_target_id(); + } else { + clear_has_target_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.UnblockPlayerRequest.target_id) +} + +// ------------------------------------------------------------------- + +// BlockedPlayerAddedNotification + +// required .bgs.protocol.user_manager.v1.BlockedPlayer player = 1; +inline bool BlockedPlayerAddedNotification::has_player() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void BlockedPlayerAddedNotification::set_has_player() { + _has_bits_[0] |= 0x00000001u; +} +inline void BlockedPlayerAddedNotification::clear_has_player() { + _has_bits_[0] &= ~0x00000001u; +} +inline void BlockedPlayerAddedNotification::clear_player() { + if (player_ != NULL) player_->::bgs::protocol::user_manager::v1::BlockedPlayer::Clear(); + clear_has_player(); +} +inline const ::bgs::protocol::user_manager::v1::BlockedPlayer& BlockedPlayerAddedNotification::player() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification.player) + return player_ != NULL ? *player_ : *default_instance_->player_; +} +inline ::bgs::protocol::user_manager::v1::BlockedPlayer* BlockedPlayerAddedNotification::mutable_player() { + set_has_player(); + if (player_ == NULL) player_ = new ::bgs::protocol::user_manager::v1::BlockedPlayer; + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification.player) + return player_; +} +inline ::bgs::protocol::user_manager::v1::BlockedPlayer* BlockedPlayerAddedNotification::release_player() { + clear_has_player(); + ::bgs::protocol::user_manager::v1::BlockedPlayer* temp = player_; + player_ = NULL; + return temp; +} +inline void BlockedPlayerAddedNotification::set_allocated_player(::bgs::protocol::user_manager::v1::BlockedPlayer* player) { + delete player_; + player_ = player; + if (player) { + set_has_player(); + } else { + clear_has_player(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification.player) +} + +// optional .bgs.protocol.EntityId game_account_id = 2; +inline bool BlockedPlayerAddedNotification::has_game_account_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void BlockedPlayerAddedNotification::set_has_game_account_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void BlockedPlayerAddedNotification::clear_has_game_account_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void BlockedPlayerAddedNotification::clear_game_account_id() { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_game_account_id(); +} +inline const ::bgs::protocol::EntityId& BlockedPlayerAddedNotification::game_account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification.game_account_id) + return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_; +} +inline ::bgs::protocol::EntityId* BlockedPlayerAddedNotification::mutable_game_account_id() { + set_has_game_account_id(); + if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification.game_account_id) + return game_account_id_; +} +inline ::bgs::protocol::EntityId* BlockedPlayerAddedNotification::release_game_account_id() { + clear_has_game_account_id(); + ::bgs::protocol::EntityId* temp = game_account_id_; + game_account_id_ = NULL; + return temp; +} +inline void BlockedPlayerAddedNotification::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) { + delete game_account_id_; + game_account_id_ = game_account_id; + if (game_account_id) { + set_has_game_account_id(); + } else { + clear_has_game_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification.game_account_id) +} + +// optional .bgs.protocol.EntityId account_id = 3; +inline bool BlockedPlayerAddedNotification::has_account_id() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void BlockedPlayerAddedNotification::set_has_account_id() { + _has_bits_[0] |= 0x00000004u; +} +inline void BlockedPlayerAddedNotification::clear_has_account_id() { + _has_bits_[0] &= ~0x00000004u; +} +inline void BlockedPlayerAddedNotification::clear_account_id() { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_account_id(); +} +inline const ::bgs::protocol::EntityId& BlockedPlayerAddedNotification::account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification.account_id) + return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_; +} +inline ::bgs::protocol::EntityId* BlockedPlayerAddedNotification::mutable_account_id() { + set_has_account_id(); + if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification.account_id) + return account_id_; +} +inline ::bgs::protocol::EntityId* BlockedPlayerAddedNotification::release_account_id() { + clear_has_account_id(); + ::bgs::protocol::EntityId* temp = account_id_; + account_id_ = NULL; + return temp; +} +inline void BlockedPlayerAddedNotification::set_allocated_account_id(::bgs::protocol::EntityId* account_id) { + delete account_id_; + account_id_ = account_id; + if (account_id) { + set_has_account_id(); + } else { + clear_has_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification.account_id) +} + +// ------------------------------------------------------------------- + +// BlockedPlayerRemovedNotification + +// required .bgs.protocol.user_manager.v1.BlockedPlayer player = 1; +inline bool BlockedPlayerRemovedNotification::has_player() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void BlockedPlayerRemovedNotification::set_has_player() { + _has_bits_[0] |= 0x00000001u; +} +inline void BlockedPlayerRemovedNotification::clear_has_player() { + _has_bits_[0] &= ~0x00000001u; +} +inline void BlockedPlayerRemovedNotification::clear_player() { + if (player_ != NULL) player_->::bgs::protocol::user_manager::v1::BlockedPlayer::Clear(); + clear_has_player(); +} +inline const ::bgs::protocol::user_manager::v1::BlockedPlayer& BlockedPlayerRemovedNotification::player() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification.player) + return player_ != NULL ? *player_ : *default_instance_->player_; +} +inline ::bgs::protocol::user_manager::v1::BlockedPlayer* BlockedPlayerRemovedNotification::mutable_player() { + set_has_player(); + if (player_ == NULL) player_ = new ::bgs::protocol::user_manager::v1::BlockedPlayer; + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification.player) + return player_; +} +inline ::bgs::protocol::user_manager::v1::BlockedPlayer* BlockedPlayerRemovedNotification::release_player() { + clear_has_player(); + ::bgs::protocol::user_manager::v1::BlockedPlayer* temp = player_; + player_ = NULL; + return temp; +} +inline void BlockedPlayerRemovedNotification::set_allocated_player(::bgs::protocol::user_manager::v1::BlockedPlayer* player) { + delete player_; + player_ = player; + if (player) { + set_has_player(); + } else { + clear_has_player(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification.player) +} + +// optional .bgs.protocol.EntityId game_account_id = 2; +inline bool BlockedPlayerRemovedNotification::has_game_account_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void BlockedPlayerRemovedNotification::set_has_game_account_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void BlockedPlayerRemovedNotification::clear_has_game_account_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void BlockedPlayerRemovedNotification::clear_game_account_id() { + if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_game_account_id(); +} +inline const ::bgs::protocol::EntityId& BlockedPlayerRemovedNotification::game_account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification.game_account_id) + return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_; +} +inline ::bgs::protocol::EntityId* BlockedPlayerRemovedNotification::mutable_game_account_id() { + set_has_game_account_id(); + if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification.game_account_id) + return game_account_id_; +} +inline ::bgs::protocol::EntityId* BlockedPlayerRemovedNotification::release_game_account_id() { + clear_has_game_account_id(); + ::bgs::protocol::EntityId* temp = game_account_id_; + game_account_id_ = NULL; + return temp; +} +inline void BlockedPlayerRemovedNotification::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) { + delete game_account_id_; + game_account_id_ = game_account_id; + if (game_account_id) { + set_has_game_account_id(); + } else { + clear_has_game_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification.game_account_id) +} + +// optional .bgs.protocol.EntityId account_id = 3; +inline bool BlockedPlayerRemovedNotification::has_account_id() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void BlockedPlayerRemovedNotification::set_has_account_id() { + _has_bits_[0] |= 0x00000004u; +} +inline void BlockedPlayerRemovedNotification::clear_has_account_id() { + _has_bits_[0] &= ~0x00000004u; +} +inline void BlockedPlayerRemovedNotification::clear_account_id() { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_account_id(); +} +inline const ::bgs::protocol::EntityId& BlockedPlayerRemovedNotification::account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification.account_id) + return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_; +} +inline ::bgs::protocol::EntityId* BlockedPlayerRemovedNotification::mutable_account_id() { + set_has_account_id(); + if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification.account_id) + return account_id_; +} +inline ::bgs::protocol::EntityId* BlockedPlayerRemovedNotification::release_account_id() { + clear_has_account_id(); + ::bgs::protocol::EntityId* temp = account_id_; + account_id_ = NULL; + return temp; +} +inline void BlockedPlayerRemovedNotification::set_allocated_account_id(::bgs::protocol::EntityId* account_id) { + delete account_id_; + account_id_ = account_id; + if (account_id) { + set_has_account_id(); + } else { + clear_has_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification.account_id) +} + +// ------------------------------------------------------------------- + +// RecentPlayersAddedNotification + +// repeated .bgs.protocol.user_manager.v1.RecentPlayer player = 1; +inline int RecentPlayersAddedNotification::player_size() const { + return player_.size(); +} +inline void RecentPlayersAddedNotification::clear_player() { + player_.Clear(); +} +inline const ::bgs::protocol::user_manager::v1::RecentPlayer& RecentPlayersAddedNotification::player(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification.player) + return player_.Get(index); +} +inline ::bgs::protocol::user_manager::v1::RecentPlayer* RecentPlayersAddedNotification::mutable_player(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification.player) + return player_.Mutable(index); +} +inline ::bgs::protocol::user_manager::v1::RecentPlayer* RecentPlayersAddedNotification::add_player() { + // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification.player) + return player_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >& +RecentPlayersAddedNotification::player() const { + // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification.player) + return player_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >* +RecentPlayersAddedNotification::mutable_player() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification.player) + return &player_; +} + +// ------------------------------------------------------------------- + +// RecentPlayersRemovedNotification + +// repeated .bgs.protocol.user_manager.v1.RecentPlayer player = 1; +inline int RecentPlayersRemovedNotification::player_size() const { + return player_.size(); +} +inline void RecentPlayersRemovedNotification::clear_player() { + player_.Clear(); +} +inline const ::bgs::protocol::user_manager::v1::RecentPlayer& RecentPlayersRemovedNotification::player(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification.player) + return player_.Get(index); +} +inline ::bgs::protocol::user_manager::v1::RecentPlayer* RecentPlayersRemovedNotification::mutable_player(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification.player) + return player_.Mutable(index); +} +inline ::bgs::protocol::user_manager::v1::RecentPlayer* RecentPlayersRemovedNotification::add_player() { + // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification.player) + return player_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >& +RecentPlayersRemovedNotification::player() const { + // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification.player) + return player_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >* +RecentPlayersRemovedNotification::mutable_player() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification.player) + return &player_; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace user_manager +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_user_5fmanager_5fservice_2eproto__INCLUDED diff --git a/src/server/proto/Client/user_manager_types.pb.cc b/src/server/proto/Client/user_manager_types.pb.cc new file mode 100644 index 00000000000..c296b09230f --- /dev/null +++ b/src/server/proto/Client/user_manager_types.pb.cc @@ -0,0 +1,1009 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: user_manager_types.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "user_manager_types.pb.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include "Log.h" +// @@protoc_insertion_point(includes) + +// Fix stupid windows.h included from Log.h->Common.h +#ifdef SendMessage +#undef SendMessage +#endif + +namespace bgs { +namespace protocol { +namespace user_manager { +namespace v1 { + +namespace { + +const ::google::protobuf::Descriptor* RecentPlayer_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + RecentPlayer_reflection_ = NULL; +const ::google::protobuf::Descriptor* BlockedPlayer_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + BlockedPlayer_reflection_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_user_5fmanager_5ftypes_2eproto() { + protobuf_AddDesc_user_5fmanager_5ftypes_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "user_manager_types.proto"); + GOOGLE_CHECK(file != NULL); + RecentPlayer_descriptor_ = file->message_type(0); + static const int RecentPlayer_offsets_[6] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayer, entity_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayer, program_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayer, timestamp_played_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayer, attributes_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayer, id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayer, counter_), + }; + RecentPlayer_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + RecentPlayer_descriptor_, + RecentPlayer::default_instance_, + RecentPlayer_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayer, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayer, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(RecentPlayer)); + BlockedPlayer_descriptor_ = file->message_type(1); + static const int BlockedPlayer_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayer, account_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayer, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayer, role_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayer, privileges_), + }; + BlockedPlayer_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + BlockedPlayer_descriptor_, + BlockedPlayer::default_instance_, + BlockedPlayer_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayer, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayer, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(BlockedPlayer)); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_user_5fmanager_5ftypes_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + RecentPlayer_descriptor_, &RecentPlayer::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + BlockedPlayer_descriptor_, &BlockedPlayer::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_user_5fmanager_5ftypes_2eproto() { + delete RecentPlayer::default_instance_; + delete RecentPlayer_reflection_; + delete BlockedPlayer::default_instance_; + delete BlockedPlayer_reflection_; +} + +void protobuf_AddDesc_user_5fmanager_5ftypes_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto(); + ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\030user_manager_types.proto\022\034bgs.protocol" + ".user_manager.v1\032\022entity_types.proto\032\025at" + "tribute_types.proto\"\264\001\n\014RecentPlayer\022)\n\t" + "entity_id\030\001 \002(\0132\026.bgs.protocol.EntityId\022" + "\017\n\007program\030\002 \001(\t\022\030\n\020timestamp_played\030\003 \001" + "(\006\022+\n\nattributes\030\004 \003(\0132\027.bgs.protocol.At" + "tribute\022\r\n\002id\030\005 \001(\007:\0010\022\022\n\007counter\030\006 \001(\007:" + "\0010\"r\n\rBlockedPlayer\022*\n\naccount_id\030\001 \002(\0132" + "\026.bgs.protocol.EntityId\022\014\n\004name\030\002 \001(\t\022\020\n" + "\004role\030\003 \003(\rB\002\020\001\022\025\n\nprivileges\030\004 \001(\004:\0010B\002" + "H\001", 402); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "user_manager_types.proto", &protobuf_RegisterTypes); + RecentPlayer::default_instance_ = new RecentPlayer(); + BlockedPlayer::default_instance_ = new BlockedPlayer(); + RecentPlayer::default_instance_->InitAsDefaultInstance(); + BlockedPlayer::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_user_5fmanager_5ftypes_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_user_5fmanager_5ftypes_2eproto { + StaticDescriptorInitializer_user_5fmanager_5ftypes_2eproto() { + protobuf_AddDesc_user_5fmanager_5ftypes_2eproto(); + } +} static_descriptor_initializer_user_5fmanager_5ftypes_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int RecentPlayer::kEntityIdFieldNumber; +const int RecentPlayer::kProgramFieldNumber; +const int RecentPlayer::kTimestampPlayedFieldNumber; +const int RecentPlayer::kAttributesFieldNumber; +const int RecentPlayer::kIdFieldNumber; +const int RecentPlayer::kCounterFieldNumber; +#endif // !_MSC_VER + +RecentPlayer::RecentPlayer() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.RecentPlayer) +} + +void RecentPlayer::InitAsDefaultInstance() { + entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +RecentPlayer::RecentPlayer(const RecentPlayer& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.RecentPlayer) +} + +void RecentPlayer::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + entity_id_ = NULL; + program_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + timestamp_played_ = GOOGLE_ULONGLONG(0); + id_ = 0u; + counter_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +RecentPlayer::~RecentPlayer() { + // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.RecentPlayer) + SharedDtor(); +} + +void RecentPlayer::SharedDtor() { + if (program_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete program_; + } + if (this != default_instance_) { + delete entity_id_; + } +} + +void RecentPlayer::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* RecentPlayer::descriptor() { + protobuf_AssignDescriptorsOnce(); + return RecentPlayer_descriptor_; +} + +const RecentPlayer& RecentPlayer::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5ftypes_2eproto(); + return *default_instance_; +} + +RecentPlayer* RecentPlayer::default_instance_ = NULL; + +RecentPlayer* RecentPlayer::New() const { + return new RecentPlayer; +} + +void RecentPlayer::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast( \ + &reinterpret_cast(16)->f) - \ + reinterpret_cast(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] & 55) { + ZR_(id_, counter_); + if (has_entity_id()) { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_program()) { + if (program_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + program_->clear(); + } + } + timestamp_played_ = GOOGLE_ULONGLONG(0); + } + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + attributes_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool RecentPlayer::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.RecentPlayer) + 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)) { + // required .bgs.protocol.EntityId entity_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_entity_id())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(18)) goto parse_program; + break; + } + + // optional string program = 2; + case 2: { + if (tag == 18) { + parse_program: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_program())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->program().data(), this->program().length(), + ::google::protobuf::internal::WireFormat::PARSE, + "program"); + } else { + goto handle_unusual; + } + if (input->ExpectTag(25)) goto parse_timestamp_played; + break; + } + + // optional fixed64 timestamp_played = 3; + case 3: { + if (tag == 25) { + parse_timestamp_played: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, ×tamp_played_))); + set_has_timestamp_played(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_attributes; + break; + } + + // repeated .bgs.protocol.Attribute attributes = 4; + case 4: { + if (tag == 34) { + parse_attributes: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_attributes())); + } else { + goto handle_unusual; + } + if (input->ExpectTag(34)) goto parse_attributes; + if (input->ExpectTag(45)) goto parse_id; + break; + } + + // optional fixed32 id = 5 [default = 0]; + case 5: { + if (tag == 45) { + parse_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &id_))); + set_has_id(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(53)) goto parse_counter; + break; + } + + // optional fixed32 counter = 6 [default = 0]; + case 6: { + if (tag == 53) { + parse_counter: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &counter_))); + set_has_counter(); + } 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:bgs.protocol.user_manager.v1.RecentPlayer) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.RecentPlayer) + return false; +#undef DO_ +} + +void RecentPlayer::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.RecentPlayer) + // required .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->entity_id(), output); + } + + // optional string program = 2; + if (has_program()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->program().data(), this->program().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "program"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->program(), output); + } + + // optional fixed64 timestamp_played = 3; + if (has_timestamp_played()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->timestamp_played(), output); + } + + // repeated .bgs.protocol.Attribute attributes = 4; + for (int i = 0; i < this->attributes_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->attributes(i), output); + } + + // optional fixed32 id = 5 [default = 0]; + if (has_id()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->id(), output); + } + + // optional fixed32 counter = 6 [default = 0]; + if (has_counter()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(6, this->counter(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.RecentPlayer) +} + +::google::protobuf::uint8* RecentPlayer::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.RecentPlayer) + // required .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->entity_id(), target); + } + + // optional string program = 2; + if (has_program()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->program().data(), this->program().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "program"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->program(), target); + } + + // optional fixed64 timestamp_played = 3; + if (has_timestamp_played()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->timestamp_played(), target); + } + + // repeated .bgs.protocol.Attribute attributes = 4; + for (int i = 0; i < this->attributes_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->attributes(i), target); + } + + // optional fixed32 id = 5 [default = 0]; + if (has_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->id(), target); + } + + // optional fixed32 counter = 6 [default = 0]; + if (has_counter()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(6, this->counter(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.RecentPlayer) + return target; +} + +int RecentPlayer::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.EntityId entity_id = 1; + if (has_entity_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->entity_id()); + } + + // optional string program = 2; + if (has_program()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->program()); + } + + // optional fixed64 timestamp_played = 3; + if (has_timestamp_played()) { + total_size += 1 + 8; + } + + // optional fixed32 id = 5 [default = 0]; + if (has_id()) { + total_size += 1 + 4; + } + + // optional fixed32 counter = 6 [default = 0]; + if (has_counter()) { + total_size += 1 + 4; + } + + } + // repeated .bgs.protocol.Attribute attributes = 4; + total_size += 1 * this->attributes_size(); + for (int i = 0; i < this->attributes_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->attributes(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 RecentPlayer::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const RecentPlayer* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void RecentPlayer::MergeFrom(const RecentPlayer& from) { + GOOGLE_CHECK_NE(&from, this); + attributes_.MergeFrom(from.attributes_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_entity_id()) { + mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id()); + } + if (from.has_program()) { + set_program(from.program()); + } + if (from.has_timestamp_played()) { + set_timestamp_played(from.timestamp_played()); + } + if (from.has_id()) { + set_id(from.id()); + } + if (from.has_counter()) { + set_counter(from.counter()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void RecentPlayer::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RecentPlayer::CopyFrom(const RecentPlayer& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RecentPlayer::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_entity_id()) { + if (!this->entity_id().IsInitialized()) return false; + } + if (!::google::protobuf::internal::AllAreInitialized(this->attributes())) return false; + return true; +} + +void RecentPlayer::Swap(RecentPlayer* other) { + if (other != this) { + std::swap(entity_id_, other->entity_id_); + std::swap(program_, other->program_); + std::swap(timestamp_played_, other->timestamp_played_); + attributes_.Swap(&other->attributes_); + std::swap(id_, other->id_); + std::swap(counter_, other->counter_); + 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 RecentPlayer::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = RecentPlayer_descriptor_; + metadata.reflection = RecentPlayer_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int BlockedPlayer::kAccountIdFieldNumber; +const int BlockedPlayer::kNameFieldNumber; +const int BlockedPlayer::kRoleFieldNumber; +const int BlockedPlayer::kPrivilegesFieldNumber; +#endif // !_MSC_VER + +BlockedPlayer::BlockedPlayer() + : ::google::protobuf::Message() { + SharedCtor(); + // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.BlockedPlayer) +} + +void BlockedPlayer::InitAsDefaultInstance() { + account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance()); +} + +BlockedPlayer::BlockedPlayer(const BlockedPlayer& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.BlockedPlayer) +} + +void BlockedPlayer::SharedCtor() { + ::google::protobuf::internal::GetEmptyString(); + _cached_size_ = 0; + account_id_ = NULL; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + privileges_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +BlockedPlayer::~BlockedPlayer() { + // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.BlockedPlayer) + SharedDtor(); +} + +void BlockedPlayer::SharedDtor() { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete name_; + } + if (this != default_instance_) { + delete account_id_; + } +} + +void BlockedPlayer::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* BlockedPlayer::descriptor() { + protobuf_AssignDescriptorsOnce(); + return BlockedPlayer_descriptor_; +} + +const BlockedPlayer& BlockedPlayer::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5ftypes_2eproto(); + return *default_instance_; +} + +BlockedPlayer* BlockedPlayer::default_instance_ = NULL; + +BlockedPlayer* BlockedPlayer::New() const { + return new BlockedPlayer; +} + +void BlockedPlayer::Clear() { + if (_has_bits_[0 / 32] & 11) { + if (has_account_id()) { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + } + if (has_name()) { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_->clear(); + } + } + privileges_ = GOOGLE_ULONGLONG(0); + } + role_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool BlockedPlayer::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.BlockedPlayer) + 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)) { + // required .bgs.protocol.EntityId account_id = 1; + case 1: { + if (tag == 10) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_account_id())); + } 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_role; + break; + } + + // repeated uint32 role = 3 [packed = true]; + case 3: { + if (tag == 26) { + parse_role: + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, this->mutable_role()))); + } else if (tag == 24) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + 1, 26, input, this->mutable_role()))); + } else { + goto handle_unusual; + } + if (input->ExpectTag(32)) goto parse_privileges; + break; + } + + // optional uint64 privileges = 4 [default = 0]; + case 4: { + if (tag == 32) { + parse_privileges: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, &privileges_))); + set_has_privileges(); + } 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:bgs.protocol.user_manager.v1.BlockedPlayer) + return true; +failure: + // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.BlockedPlayer) + return false; +#undef DO_ +} + +void BlockedPlayer::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.BlockedPlayer) + // required .bgs.protocol.EntityId account_id = 1; + if (has_account_id()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->account_id(), 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 uint32 role = 3 [packed = true]; + if (this->role_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(3, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_role_cached_byte_size_); + } + for (int i = 0; i < this->role_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag( + this->role(i), output); + } + + // optional uint64 privileges = 4 [default = 0]; + if (has_privileges()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->privileges(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.BlockedPlayer) +} + +::google::protobuf::uint8* BlockedPlayer::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.BlockedPlayer) + // required .bgs.protocol.EntityId account_id = 1; + if (has_account_id()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->account_id(), 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 uint32 role = 3 [packed = true]; + if (this->role_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 3, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + _role_cached_byte_size_, target); + } + for (int i = 0; i < this->role_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt32NoTagToArray(this->role(i), target); + } + + // optional uint64 privileges = 4 [default = 0]; + if (has_privileges()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->privileges(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.BlockedPlayer) + return target; +} + +int BlockedPlayer::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .bgs.protocol.EntityId account_id = 1; + if (has_account_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->account_id()); + } + + // optional string name = 2; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // optional uint64 privileges = 4 [default = 0]; + if (has_privileges()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt64Size( + this->privileges()); + } + + } + // repeated uint32 role = 3 [packed = true]; + { + int data_size = 0; + for (int i = 0; i < this->role_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite:: + UInt32Size(this->role(i)); + } + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _role_cached_byte_size_ = data_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_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 BlockedPlayer::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const BlockedPlayer* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void BlockedPlayer::MergeFrom(const BlockedPlayer& from) { + GOOGLE_CHECK_NE(&from, this); + role_.MergeFrom(from.role_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_account_id()) { + mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id()); + } + if (from.has_name()) { + set_name(from.name()); + } + if (from.has_privileges()) { + set_privileges(from.privileges()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void BlockedPlayer::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void BlockedPlayer::CopyFrom(const BlockedPlayer& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BlockedPlayer::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_account_id()) { + if (!this->account_id().IsInitialized()) return false; + } + return true; +} + +void BlockedPlayer::Swap(BlockedPlayer* other) { + if (other != this) { + std::swap(account_id_, other->account_id_); + std::swap(name_, other->name_); + role_.Swap(&other->role_); + std::swap(privileges_, other->privileges_); + 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 BlockedPlayer::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = BlockedPlayer_descriptor_; + metadata.reflection = BlockedPlayer_reflection_; + return metadata; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace user_manager +} // namespace protocol +} // namespace bgs + +// @@protoc_insertion_point(global_scope) diff --git a/src/server/proto/Client/user_manager_types.pb.h b/src/server/proto/Client/user_manager_types.pb.h new file mode 100644 index 00000000000..93b4a04e802 --- /dev/null +++ b/src/server/proto/Client/user_manager_types.pb.h @@ -0,0 +1,727 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: user_manager_types.proto + +#ifndef PROTOBUF_user_5fmanager_5ftypes_2eproto__INCLUDED +#define PROTOBUF_user_5fmanager_5ftypes_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2006000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include "entity_types.pb.h" +#include "attribute_types.pb.h" +#include "Define.h" // for TRINITY_SHARED_API +// @@protoc_insertion_point(includes) + +namespace bgs { +namespace protocol { +namespace user_manager { +namespace v1 { + +// Internal implementation detail -- do not call these. +void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5ftypes_2eproto(); +void protobuf_AssignDesc_user_5fmanager_5ftypes_2eproto(); +void protobuf_ShutdownFile_user_5fmanager_5ftypes_2eproto(); + +class RecentPlayer; +class BlockedPlayer; + +// =================================================================== + +class TC_SHARED_API RecentPlayer : public ::google::protobuf::Message { + public: + RecentPlayer(); + virtual ~RecentPlayer(); + + RecentPlayer(const RecentPlayer& from); + + inline RecentPlayer& operator=(const RecentPlayer& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const RecentPlayer& default_instance(); + + void Swap(RecentPlayer* other); + + // implements Message ---------------------------------------------- + + RecentPlayer* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const RecentPlayer& from); + void MergeFrom(const RecentPlayer& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.EntityId entity_id = 1; + inline bool has_entity_id() const; + inline void clear_entity_id(); + static const int kEntityIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& entity_id() const; + inline ::bgs::protocol::EntityId* mutable_entity_id(); + inline ::bgs::protocol::EntityId* release_entity_id(); + inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id); + + // optional string program = 2; + inline bool has_program() const; + inline void clear_program(); + static const int kProgramFieldNumber = 2; + inline const ::std::string& program() const; + inline void set_program(const ::std::string& value); + inline void set_program(const char* value); + inline void set_program(const char* value, size_t size); + inline ::std::string* mutable_program(); + inline ::std::string* release_program(); + inline void set_allocated_program(::std::string* program); + + // optional fixed64 timestamp_played = 3; + inline bool has_timestamp_played() const; + inline void clear_timestamp_played(); + static const int kTimestampPlayedFieldNumber = 3; + inline ::google::protobuf::uint64 timestamp_played() const; + inline void set_timestamp_played(::google::protobuf::uint64 value); + + // repeated .bgs.protocol.Attribute attributes = 4; + inline int attributes_size() const; + inline void clear_attributes(); + static const int kAttributesFieldNumber = 4; + inline const ::bgs::protocol::Attribute& attributes(int index) const; + inline ::bgs::protocol::Attribute* mutable_attributes(int index); + inline ::bgs::protocol::Attribute* add_attributes(); + inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& + attributes() const; + inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* + mutable_attributes(); + + // optional fixed32 id = 5 [default = 0]; + inline bool has_id() const; + inline void clear_id(); + static const int kIdFieldNumber = 5; + inline ::google::protobuf::uint32 id() const; + inline void set_id(::google::protobuf::uint32 value); + + // optional fixed32 counter = 6 [default = 0]; + inline bool has_counter() const; + inline void clear_counter(); + static const int kCounterFieldNumber = 6; + inline ::google::protobuf::uint32 counter() const; + inline void set_counter(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.RecentPlayer) + private: + inline void set_has_entity_id(); + inline void clear_has_entity_id(); + inline void set_has_program(); + inline void clear_has_program(); + inline void set_has_timestamp_played(); + inline void clear_has_timestamp_played(); + inline void set_has_id(); + inline void clear_has_id(); + inline void set_has_counter(); + inline void clear_has_counter(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* entity_id_; + ::std::string* program_; + ::google::protobuf::uint64 timestamp_played_; + ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attributes_; + ::google::protobuf::uint32 id_; + ::google::protobuf::uint32 counter_; + friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5ftypes_2eproto(); + friend void protobuf_AssignDesc_user_5fmanager_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_user_5fmanager_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static RecentPlayer* default_instance_; +}; +// ------------------------------------------------------------------- + +class TC_SHARED_API BlockedPlayer : public ::google::protobuf::Message { + public: + BlockedPlayer(); + virtual ~BlockedPlayer(); + + BlockedPlayer(const BlockedPlayer& from); + + inline BlockedPlayer& operator=(const BlockedPlayer& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const BlockedPlayer& default_instance(); + + void Swap(BlockedPlayer* other); + + // implements Message ---------------------------------------------- + + BlockedPlayer* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const BlockedPlayer& from); + void MergeFrom(const BlockedPlayer& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .bgs.protocol.EntityId account_id = 1; + inline bool has_account_id() const; + inline void clear_account_id(); + static const int kAccountIdFieldNumber = 1; + inline const ::bgs::protocol::EntityId& account_id() const; + inline ::bgs::protocol::EntityId* mutable_account_id(); + inline ::bgs::protocol::EntityId* release_account_id(); + inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id); + + // optional string name = 2; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 2; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + inline ::std::string* release_name(); + inline void set_allocated_name(::std::string* name); + + // repeated uint32 role = 3 [packed = true]; + inline int role_size() const; + inline void clear_role(); + static const int kRoleFieldNumber = 3; + inline ::google::protobuf::uint32 role(int index) const; + inline void set_role(int index, ::google::protobuf::uint32 value); + inline void add_role(::google::protobuf::uint32 value); + inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& + role() const; + inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* + mutable_role(); + + // optional uint64 privileges = 4 [default = 0]; + inline bool has_privileges() const; + inline void clear_privileges(); + static const int kPrivilegesFieldNumber = 4; + inline ::google::protobuf::uint64 privileges() const; + inline void set_privileges(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.BlockedPlayer) + private: + inline void set_has_account_id(); + inline void clear_has_account_id(); + inline void set_has_name(); + inline void clear_has_name(); + inline void set_has_privileges(); + inline void clear_has_privileges(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::bgs::protocol::EntityId* account_id_; + ::std::string* name_; + ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > role_; + mutable int _role_cached_byte_size_; + ::google::protobuf::uint64 privileges_; + friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5ftypes_2eproto(); + friend void protobuf_AssignDesc_user_5fmanager_5ftypes_2eproto(); + friend void protobuf_ShutdownFile_user_5fmanager_5ftypes_2eproto(); + + void InitAsDefaultInstance(); + static BlockedPlayer* default_instance_; +}; +// =================================================================== + + +// =================================================================== + + +// =================================================================== + +// RecentPlayer + +// required .bgs.protocol.EntityId entity_id = 1; +inline bool RecentPlayer::has_entity_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void RecentPlayer::set_has_entity_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void RecentPlayer::clear_has_entity_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void RecentPlayer::clear_entity_id() { + if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear(); + clear_has_entity_id(); +} +inline const ::bgs::protocol::EntityId& RecentPlayer::entity_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.RecentPlayer.entity_id) + return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_; +} +inline ::bgs::protocol::EntityId* RecentPlayer::mutable_entity_id() { + set_has_entity_id(); + if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.RecentPlayer.entity_id) + return entity_id_; +} +inline ::bgs::protocol::EntityId* RecentPlayer::release_entity_id() { + clear_has_entity_id(); + ::bgs::protocol::EntityId* temp = entity_id_; + entity_id_ = NULL; + return temp; +} +inline void RecentPlayer::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) { + delete entity_id_; + entity_id_ = entity_id; + if (entity_id) { + set_has_entity_id(); + } else { + clear_has_entity_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.RecentPlayer.entity_id) +} + +// optional string program = 2; +inline bool RecentPlayer::has_program() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void RecentPlayer::set_has_program() { + _has_bits_[0] |= 0x00000002u; +} +inline void RecentPlayer::clear_has_program() { + _has_bits_[0] &= ~0x00000002u; +} +inline void RecentPlayer::clear_program() { + if (program_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + program_->clear(); + } + clear_has_program(); +} +inline const ::std::string& RecentPlayer::program() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.RecentPlayer.program) + return *program_; +} +inline void RecentPlayer::set_program(const ::std::string& value) { + set_has_program(); + if (program_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + program_ = new ::std::string; + } + program_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.RecentPlayer.program) +} +inline void RecentPlayer::set_program(const char* value) { + set_has_program(); + if (program_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + program_ = new ::std::string; + } + program_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.user_manager.v1.RecentPlayer.program) +} +inline void RecentPlayer::set_program(const char* value, size_t size) { + set_has_program(); + if (program_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + program_ = new ::std::string; + } + program_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.user_manager.v1.RecentPlayer.program) +} +inline ::std::string* RecentPlayer::mutable_program() { + set_has_program(); + if (program_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + program_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.RecentPlayer.program) + return program_; +} +inline ::std::string* RecentPlayer::release_program() { + clear_has_program(); + if (program_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = program_; + program_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void RecentPlayer::set_allocated_program(::std::string* program) { + if (program_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete program_; + } + if (program) { + set_has_program(); + program_ = program; + } else { + clear_has_program(); + program_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.RecentPlayer.program) +} + +// optional fixed64 timestamp_played = 3; +inline bool RecentPlayer::has_timestamp_played() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void RecentPlayer::set_has_timestamp_played() { + _has_bits_[0] |= 0x00000004u; +} +inline void RecentPlayer::clear_has_timestamp_played() { + _has_bits_[0] &= ~0x00000004u; +} +inline void RecentPlayer::clear_timestamp_played() { + timestamp_played_ = GOOGLE_ULONGLONG(0); + clear_has_timestamp_played(); +} +inline ::google::protobuf::uint64 RecentPlayer::timestamp_played() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.RecentPlayer.timestamp_played) + return timestamp_played_; +} +inline void RecentPlayer::set_timestamp_played(::google::protobuf::uint64 value) { + set_has_timestamp_played(); + timestamp_played_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.RecentPlayer.timestamp_played) +} + +// repeated .bgs.protocol.Attribute attributes = 4; +inline int RecentPlayer::attributes_size() const { + return attributes_.size(); +} +inline void RecentPlayer::clear_attributes() { + attributes_.Clear(); +} +inline const ::bgs::protocol::Attribute& RecentPlayer::attributes(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.RecentPlayer.attributes) + return attributes_.Get(index); +} +inline ::bgs::protocol::Attribute* RecentPlayer::mutable_attributes(int index) { + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.RecentPlayer.attributes) + return attributes_.Mutable(index); +} +inline ::bgs::protocol::Attribute* RecentPlayer::add_attributes() { + // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.RecentPlayer.attributes) + return attributes_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >& +RecentPlayer::attributes() const { + // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.RecentPlayer.attributes) + return attributes_; +} +inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >* +RecentPlayer::mutable_attributes() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.RecentPlayer.attributes) + return &attributes_; +} + +// optional fixed32 id = 5 [default = 0]; +inline bool RecentPlayer::has_id() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void RecentPlayer::set_has_id() { + _has_bits_[0] |= 0x00000010u; +} +inline void RecentPlayer::clear_has_id() { + _has_bits_[0] &= ~0x00000010u; +} +inline void RecentPlayer::clear_id() { + id_ = 0u; + clear_has_id(); +} +inline ::google::protobuf::uint32 RecentPlayer::id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.RecentPlayer.id) + return id_; +} +inline void RecentPlayer::set_id(::google::protobuf::uint32 value) { + set_has_id(); + id_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.RecentPlayer.id) +} + +// optional fixed32 counter = 6 [default = 0]; +inline bool RecentPlayer::has_counter() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void RecentPlayer::set_has_counter() { + _has_bits_[0] |= 0x00000020u; +} +inline void RecentPlayer::clear_has_counter() { + _has_bits_[0] &= ~0x00000020u; +} +inline void RecentPlayer::clear_counter() { + counter_ = 0u; + clear_has_counter(); +} +inline ::google::protobuf::uint32 RecentPlayer::counter() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.RecentPlayer.counter) + return counter_; +} +inline void RecentPlayer::set_counter(::google::protobuf::uint32 value) { + set_has_counter(); + counter_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.RecentPlayer.counter) +} + +// ------------------------------------------------------------------- + +// BlockedPlayer + +// required .bgs.protocol.EntityId account_id = 1; +inline bool BlockedPlayer::has_account_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void BlockedPlayer::set_has_account_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void BlockedPlayer::clear_has_account_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void BlockedPlayer::clear_account_id() { + if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear(); + clear_has_account_id(); +} +inline const ::bgs::protocol::EntityId& BlockedPlayer::account_id() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockedPlayer.account_id) + return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_; +} +inline ::bgs::protocol::EntityId* BlockedPlayer::mutable_account_id() { + set_has_account_id(); + if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId; + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.BlockedPlayer.account_id) + return account_id_; +} +inline ::bgs::protocol::EntityId* BlockedPlayer::release_account_id() { + clear_has_account_id(); + ::bgs::protocol::EntityId* temp = account_id_; + account_id_ = NULL; + return temp; +} +inline void BlockedPlayer::set_allocated_account_id(::bgs::protocol::EntityId* account_id) { + delete account_id_; + account_id_ = account_id; + if (account_id) { + set_has_account_id(); + } else { + clear_has_account_id(); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.BlockedPlayer.account_id) +} + +// optional string name = 2; +inline bool BlockedPlayer::has_name() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void BlockedPlayer::set_has_name() { + _has_bits_[0] |= 0x00000002u; +} +inline void BlockedPlayer::clear_has_name() { + _has_bits_[0] &= ~0x00000002u; +} +inline void BlockedPlayer::clear_name() { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& BlockedPlayer::name() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockedPlayer.name) + return *name_; +} +inline void BlockedPlayer::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + name_->assign(value); + // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.BlockedPlayer.name) +} +inline void BlockedPlayer::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + name_->assign(value); + // @@protoc_insertion_point(field_set_char:bgs.protocol.user_manager.v1.BlockedPlayer.name) +} +inline void BlockedPlayer::set_name(const char* value, size_t size) { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:bgs.protocol.user_manager.v1.BlockedPlayer.name) +} +inline ::std::string* BlockedPlayer::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + name_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.BlockedPlayer.name) + return name_; +} +inline ::std::string* BlockedPlayer::release_name() { + clear_has_name(); + if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = name_; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void BlockedPlayer::set_allocated_name(::std::string* name) { + if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete name_; + } + if (name) { + set_has_name(); + name_ = name; + } else { + clear_has_name(); + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.BlockedPlayer.name) +} + +// repeated uint32 role = 3 [packed = true]; +inline int BlockedPlayer::role_size() const { + return role_.size(); +} +inline void BlockedPlayer::clear_role() { + role_.Clear(); +} +inline ::google::protobuf::uint32 BlockedPlayer::role(int index) const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockedPlayer.role) + return role_.Get(index); +} +inline void BlockedPlayer::set_role(int index, ::google::protobuf::uint32 value) { + role_.Set(index, value); + // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.BlockedPlayer.role) +} +inline void BlockedPlayer::add_role(::google::protobuf::uint32 value) { + role_.Add(value); + // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.BlockedPlayer.role) +} +inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >& +BlockedPlayer::role() const { + // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.BlockedPlayer.role) + return role_; +} +inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >* +BlockedPlayer::mutable_role() { + // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.BlockedPlayer.role) + return &role_; +} + +// optional uint64 privileges = 4 [default = 0]; +inline bool BlockedPlayer::has_privileges() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void BlockedPlayer::set_has_privileges() { + _has_bits_[0] |= 0x00000008u; +} +inline void BlockedPlayer::clear_has_privileges() { + _has_bits_[0] &= ~0x00000008u; +} +inline void BlockedPlayer::clear_privileges() { + privileges_ = GOOGLE_ULONGLONG(0); + clear_has_privileges(); +} +inline ::google::protobuf::uint64 BlockedPlayer::privileges() const { + // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockedPlayer.privileges) + return privileges_; +} +inline void BlockedPlayer::set_privileges(::google::protobuf::uint64 value) { + set_has_privileges(); + privileges_ = value; + // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.BlockedPlayer.privileges) +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace v1 +} // namespace user_manager +} // namespace protocol +} // namespace bgs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_user_5fmanager_5ftypes_2eproto__INCLUDED diff --git a/src/server/proto/PrecompiledHeaders/protoPCH.cpp b/src/server/proto/PrecompiledHeaders/protoPCH.cpp new file mode 100644 index 00000000000..ca1e45a3644 --- /dev/null +++ b/src/server/proto/PrecompiledHeaders/protoPCH.cpp @@ -0,0 +1 @@ +#include "protoPCH.h" diff --git a/src/server/proto/PrecompiledHeaders/protoPCH.h b/src/server/proto/PrecompiledHeaders/protoPCH.h new file mode 100644 index 00000000000..441e8738b5d --- /dev/null +++ b/src/server/proto/PrecompiledHeaders/protoPCH.h @@ -0,0 +1,13 @@ +#include "account_service.pb.h" +#include "authentication_service.pb.h" +#include "challenge_service.pb.h" +#include "channel_service.pb.h" +#include "connection_service.pb.h" +#include "friends_service.pb.h" +#include "game_utilities_service.pb.h" +#include "notification_types.pb.h" +#include "presence_service.pb.h" +#include "profanity_filter_config.pb.h" +#include "report_service.pb.h" +#include "resource_service.pb.h" +#include "user_manager_service.pb.h" diff --git a/src/server/proto/ServiceBase.h b/src/server/proto/ServiceBase.h new file mode 100644 index 00000000000..9e941fcf618 --- /dev/null +++ b/src/server/proto/ServiceBase.h @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2008-2016 TrinityCore + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see . + */ + +#ifndef ServiceBase_h__ +#define ServiceBase_h__ + +#include "MessageBuffer.h" +#include "Define.h" +#include +#include + +namespace google +{ + namespace protobuf + { + class Message; + } +} + +class TC_SHARED_API ServiceBase +{ +public: + virtual ~ServiceBase() { } + + virtual void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) = 0; + +protected: + virtual void SendRequest(uint32 serviceHash, uint32 methodId, google::protobuf::Message const* request, std::function callback) = 0; + virtual void SendRequest(uint32 serviceHash, uint32 methodId, google::protobuf::Message const* request) = 0; + virtual void SendResponse(uint32 serviceHash, uint32 methodId, uint32 token, uint32 status) = 0; + virtual void SendResponse(uint32 serviceHash, uint32 methodId, uint32 token, google::protobuf::Message const* response) = 0; + virtual std::string GetCallerInfo() const = 0; +}; + +#endif // ServiceBase_h__ diff --git a/src/server/shared/CMakeLists.txt b/src/server/shared/CMakeLists.txt index ce6c13bd932..052902de9c8 100644 --- a/src/server/shared/CMakeLists.txt +++ b/src/server/shared/CMakeLists.txt @@ -43,7 +43,8 @@ target_include_directories(shared target_link_libraries(shared PUBLIC database - rapidjson) + rapidjson + proto) set_target_properties(shared PROPERTIES -- cgit v1.2.3